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

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Data;
  5. using System.Data.Sql;
  6. using System.Data.Common;
  7. using System.Data.SqlClient;
  8. using StatisticMath;
  9. using Microsoft.SqlServer.Server;
  10. /// <summary>
  11. /// Модель Блэка - Шоулза
  12. /// Класс расчета премии и волатильности по опционам Call и Put
  13. /// Расчет основных греков
  14. /// Автор Есаков Денис denis[:собачко:]yesakov.com
  15. /// http://www.yesakov.com/BlackScholes/
  16. /// </summary>
  17. public class BlackScholes
  18. {
  19.   /*
  20.    * Write
  21.    * BS_CALL    Calculates the theoretical price of a call option
  22.    * BS_CDELTA   Calculates the delta (hedge ratio) of call option
  23.    * BS_CTHETA   Calculates the theta of a call
  24.    * BS_CGAMMA   Calculates the gamma of a call
  25.    * BS_CVEGA   Calculates the vega of a call
  26.    * BS_PUT    Calculates the theoretical price of a put option
  27.    * BS_PDELTA   Calculates the delta (hedge ratio) of a put
  28.    * BS_PTHETA   Calculates the theta of a put
  29.    * BS_PGAMMA   Calculates the gamma of a put
  30.    * BS_PVEGA   Calculates the vega of a put
  31.    * IV      Calculates the Implied Volatility of a Call and Put Options
  32.    * NEED
  33.    * BS_CRHO    Calculates the rho of a call
  34.    * BS_PRHO    Calculates the rho of a put
  35.    * BS_CSTD    Calculates the implied standard deviation of a call
  36.    * BS_PSTD    Calculates the implied standard deviation of a put
  37.    * FRIDAY3    Calculates the serial date for the 3rd Friday of the month
  38.    */
  39.   private readonly static double dayInYear = 365;       //Количество дней в году (расчет временного распада)
  40.   private readonly static double timeDif = 1.0 / dayInYear;  //Коэффициент дней в году
  41.   private readonly static double vegaDif = 0.01;        //Коэффициент веги
  42.   private readonly static double gammaDif = 0.1;        //Коэффициент Гаммы
  43.   public enum OptionType { Call = 1, Put };     //Перечислимый тип опционов
  44.  
  45.   #region d1
  46.   /// <summary>
  47.   /// Расчет величины d1 из формулы Блэка Шолза
  48.   /// </summary>
  49.   /// <param name="baseActive">Значение базового актива</param>
  50.   /// <param name="strike">Страйк опциона</param>
  51.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  52.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  53.   /// <param name="deviation">Стандартное отклонение</param>
  54.   /// <param name="dividend">Размер дивиденда по акциям</param>
  55.   /// <returns>значение величины d1</returns>
  56.   private static double d1(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  57.   {
  58.     return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp));
  59.   }
  60.   /// <summary>
  61.   /// Расчет величины d1 из формулы Блэка Шолза
  62.   /// </summary>
  63.   /// <param name="baseActive">Значение базового актива</param>
  64.   /// <param name="strike">Страйк опциона</param>
  65.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  66.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  67.   /// <param name="deviation">Стандартное отклонение</param>
  68.   /// <param name="dividend">Размер дивиденда по акциям</param>
  69.   /// <returns>значение величины d1</returns>
  70.   private static double d1(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  71.   {
  72.     double timeToExp = dayToExp / dayInYear;
  73.     return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp));
  74.   }
  75.  
  76.   /// <summary>
  77.   /// Расчет величины d1 из формулы Блэка Шолза
  78.   /// </summary>
  79.   /// <param name="baseActive">Значение базового актива</param>
  80.   /// <param name="strike">Страйк опциона</param>
  81.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  82.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  83.   /// <param name="deviation">Стандартное отклонение</param>
  84.   /// <returns>значение величины d1</returns>
  85.   private static double d1(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  86.   {
  87.     double dividend = 0;
  88.     return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp));
  89.   }
  90.   /// <summary>
  91.   /// Расчет величины d1 из формулы Блэка Шолза
  92.   /// </summary>
  93.   /// <param name="baseActive">Значение базового актива</param>
  94.   /// <param name="strike">Страйк опциона</param>
  95.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  96.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  97.   /// <param name="deviation">Стандартное отклонение</param>
  98.   /// <returns>значение величины d1</returns>
  99.   private static double d1(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  100.   {
  101.     double timeToExp = dayToExp / dayInYear;
  102.     double dividend = 0;
  103.     return (Math.Log(baseActive / strike) + (riskFree - dividend + deviation * deviation / (2.0)) * timeToExp) / (deviation * Math.Sqrt(timeToExp));
  104.   }
  105.   #endregion
  106.  
  107.   #region d2
  108.   /// <summary>
  109.   /// Расчет величины d2 из формулы Блэка Шолза
  110.   /// </summary>
  111.   /// <param name="baseActive">Значение базового актива</param>
  112.   /// <param name="strike">Страйк опциона</param>
  113.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  114.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  115.   /// <param name="deviation">Стандартное отклонение</param>
  116.   /// <param name="dividend">Размер дивиденда по акциям</param>
  117.   /// <returns>значение величины d2</returns>
  118.   private static double d2(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  119.   {
  120.     return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp);
  121.   }
  122.   /// <summary>
  123.   /// Расчет величины d2 из формулы Блэка Шолза
  124.   /// </summary>
  125.   /// <param name="baseActive">Значение базового актива</param>
  126.   /// <param name="strike">Страйк опциона</param>
  127.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  128.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  129.   /// <param name="deviation">Стандартное отклонение</param>
  130.   /// <param name="dividend">Размер дивиденда по акциям</param>
  131.   /// <returns>значение величины d2</returns>
  132.   private static double d2(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  133.   {
  134.     double timeToExp = dayToExp / dayInYear;
  135.     return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp);
  136.   }
  137.  
  138.  
  139.   /// <summary>
  140.   /// Расчет величины d2 из формулы Блэка Шолза
  141.   /// </summary>
  142.   /// <param name="baseActive">Значение базового актива</param>
  143.   /// <param name="strike">Страйк опциона</param>
  144.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  145.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  146.   /// <param name="deviation">Стандартное отклонение</param>
  147.   /// <returns>значение величины d2</returns>
  148.   private static double d2(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  149.   {
  150.     double dividend = 0;
  151.     return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp);
  152.   }
  153.   /// <summary>
  154.   /// Расчет величины d2 из формулы Блэка Шолза
  155.   /// </summary>
  156.   /// <param name="baseActive">Значение базового актива</param>
  157.   /// <param name="strike">Страйк опциона</param>
  158.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  159.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  160.   /// <param name="deviation">Стандартное отклонение</param>
  161.   /// <returns>значение величины d2</returns>
  162.   private static double d2(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  163.   {
  164.     double dividend = 0;
  165.     double timeToExp = dayToExp / dayInYear;
  166.     return d1(baseActive, strike, timeToExp, riskFree, deviation, dividend) - (deviation) * Math.Sqrt(timeToExp);
  167.   }
  168.  
  169.   #endregion
  170.  
  171.   #region BS_CALL
  172.   /*[SqlFunction()]
  173.   public static System.Data.SqlTypes.SqlDouble test()
  174.   {
  175.     return (float)0.1;
  176.   }*/
  177.  
  178.   /// <summary>
  179.   /// Расчет премии по опциону Call
  180.   /// </summary>
  181.   /// <param name="baseActive">Значение базового актива</param>
  182.   /// <param name="strike">Страйк опциона</param>
  183.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  184.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  185.   /// <param name="deviation">Стандартное отклонение</param>
  186.   /// <param name="dividend">Размер дивиденда по акциям</param>
  187.   /// <returns>Премию опциона Call</returns>
  188.   public static double BS_CALL(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  189.   {
  190.     double expRate = Math.Exp(-riskFree * timeToExp);
  191.     double expDiv = Math.Exp(-dividend * timeToExp);
  192.  
  193.     return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  194.       strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  195.   }
  196.  
  197.  
  198.   [SqlFunction()]
  199.   public static System.Data.SqlTypes.SqlDouble FBS_CALL01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  200.   {
  201.     return (float)BS_CALL(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  202.   }
  203.  
  204.   [Microsoft.SqlServer.Server.SqlProcedure(Name = "BS_CALL01")]
  205.   public static void BS_CALL01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  206.   {
  207.     double result = BS_CALL(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  208.     SqlConnection conn = new SqlConnection("Context Connection=true");
  209.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  210.     cmd.Parameters.Add(new SqlParameter("@result", result));
  211.     conn.Open();
  212.  
  213.     SqlDataReader rdr = cmd.ExecuteReader();
  214.     SqlContext.Pipe.Send(rdr);
  215.  
  216.     rdr.Close();
  217.     conn.Close();
  218.   }
  219.   /// <summary>
  220.   /// Расчет премии по опциону Call
  221.   /// </summary>
  222.   /// <param name="baseActive">Значение базового актива</param>
  223.   /// <param name="strike">Страйк опциона</param>
  224.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  225.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  226.   /// <param name="deviation">Стандартное отклонение</param>
  227.   /// <param name="dividend">Размер дивиденда по акциям</param>
  228.   /// <returns>Премию опциона Call</returns>
  229.   public static double BS_CALL(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  230.   {
  231.     double timeToExp = dayToExp / dayInYear;
  232.     double expRate = Math.Exp(-riskFree * timeToExp);
  233.     double expDiv = Math.Exp(-dividend * timeToExp);
  234.  
  235.     return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  236.       strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  237.   }
  238.  
  239.   [SqlFunction()]
  240.   public static System.Data.SqlTypes.SqlDouble FBS_CALL02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  241.   {
  242.     return (float)BS_CALL(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  243.   }
  244.  
  245.   [Microsoft.SqlServer.Server.SqlProcedure(Name = "BS_CALL02")]
  246.   public static void BS_CALL02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  247.   {
  248.     double result = BS_CALL(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  249.     SqlConnection conn = new SqlConnection("Context Connection=true");
  250.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  251.     cmd.Parameters.Add(new SqlParameter("@result", result));
  252.     conn.Open();
  253.  
  254.     SqlDataReader rdr = cmd.ExecuteReader();
  255.     SqlContext.Pipe.Send(rdr);
  256.  
  257.     rdr.Close();
  258.     conn.Close();
  259.   }
  260.  
  261.  
  262.   /// <summary>
  263.   /// Расчет премии по опциону Call
  264.   /// </summary>
  265.   /// <param name="baseActive">Значение базового актива</param>
  266.   /// <param name="strike">Страйк опциона</param>
  267.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  268.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  269.   /// <param name="deviation">Стандартное отклонение</param>
  270.   /// <returns>Премию опциона Call</returns>
  271.   public static double BS_CALL(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  272.   {
  273.     double dividend = 0;
  274.     double expRate = Math.Exp(-riskFree * timeToExp);
  275.     double expDiv = Math.Exp(-dividend * timeToExp);
  276.  
  277.     return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  278.       strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  279.   }
  280.  
  281.   [SqlFunction()]
  282.   public static System.Data.SqlTypes.SqlDouble FBS_CALL03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  283.   {
  284.     return (float)BS_CALL(baseActive, strike, timeToExp, riskFree, deviation);
  285.   }
  286.  
  287.   [SqlProcedure(Name = "BS_CALL03")]
  288.   public static void BS_CALL03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  289.   {
  290.     double result = BS_CALL(baseActive, strike, timeToExp, riskFree, deviation);
  291.     SqlConnection conn = new SqlConnection("Context Connection=true");
  292.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  293.     cmd.Parameters.Add(new SqlParameter("@result", result));
  294.     conn.Open();
  295.  
  296.     SqlDataReader rdr = cmd.ExecuteReader();
  297.     SqlContext.Pipe.Send(rdr);
  298.  
  299.     rdr.Close();
  300.     conn.Close();
  301.   }
  302.   /// <summary>
  303.   /// Расчет премии по опциону Call
  304.   /// </summary>
  305.   /// <param name="baseActive">Значение базового актива</param>
  306.   /// <param name="strike">Страйк опциона</param>
  307.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  308.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  309.   /// <param name="deviation">Стандартное отклонение</param>
  310.   /// <returns>Премию опциона Call</returns>
  311.   public static double BS_CALL(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  312.   {
  313.     double timeToExp = dayToExp / dayInYear;
  314.     double dividend = 0;
  315.     double expRate = Math.Exp(-riskFree * timeToExp);
  316.     double expDiv = Math.Exp(-dividend * timeToExp);
  317.  
  318.     return baseActive * expDiv * Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  319.       strike * expRate * Statistic.N(d2(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  320.   }
  321.  
  322.   [SqlFunction()]
  323.   public static System.Data.SqlTypes.SqlDouble FBS_CALL04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  324.   {
  325.     return (float)BS_CALL(baseActive, strike, dayToExp, riskFree, deviation);
  326.   }
  327.  
  328.   [SqlProcedure(Name = "BS_CALL04")]
  329.   public static void BS_CALL04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  330.   {
  331.     double result = BS_CALL(baseActive, strike, dayToExp, riskFree, deviation);
  332.     SqlConnection conn = new SqlConnection("Context Connection=true");
  333.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  334.     cmd.Parameters.Add(new SqlParameter("@result", result));
  335.     conn.Open();
  336.  
  337.     SqlDataReader rdr = cmd.ExecuteReader();
  338.     SqlContext.Pipe.Send(rdr);
  339.  
  340.     rdr.Close();
  341.     conn.Close();
  342.   }
  343.   #endregion
  344.  
  345.   #region BS_PUT
  346.   /// <summary>
  347.   /// Расчет премии по опциону Put
  348.   /// </summary>
  349.   /// <param name="baseActive">Значение базового актива</param>
  350.   /// <param name="strike">Страйк опциона</param>
  351.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  352.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  353.   /// <param name="deviation">Стандартное отклонение</param>
  354.   /// <param name="dividend">Размер дивиденда по акциям</param>
  355.   /// <returns>Премию опциона Put</returns>
  356.   public static double BS_PUT(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  357.   {
  358.     double expRate = Math.Exp(-riskFree * timeToExp);
  359.     double expDiv = Math.Exp(-dividend * timeToExp);
  360.  
  361.     return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  362.       baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  363.   }
  364.  
  365.   [SqlFunction()]
  366.   public static System.Data.SqlTypes.SqlDouble FBS_PUT01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  367.   {
  368.     return (float)BS_PUT(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  369.   }
  370.  
  371.   [SqlProcedure(Name = "BS_PUT01")]
  372.   public static void BS_PUT01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  373.   {
  374.     double result = BS_PUT(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  375.     SqlConnection conn = new SqlConnection("Context Connection=true");
  376.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  377.     cmd.Parameters.Add(new SqlParameter("@result", result));
  378.     conn.Open();
  379.  
  380.     SqlDataReader rdr = cmd.ExecuteReader();
  381.     SqlContext.Pipe.Send(rdr);
  382.  
  383.     rdr.Close();
  384.     conn.Close();
  385.   }
  386.   /// <summary>
  387.   /// Расчет премии по опциону Put
  388.   /// </summary>
  389.   /// <param name="baseActive">Значение базового актива</param>
  390.   /// <param name="strike">Страйк опциона</param>
  391.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  392.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  393.   /// <param name="deviation">Стандартное отклонение</param>
  394.   /// <param name="dividend">Размер дивиденда по акциям</param>
  395.   /// <returns>Премию опциона Put</returns>
  396.   public static double BS_PUT(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  397.   {
  398.     double timeToExp = dayToExp / dayInYear;
  399.     double expRate = Math.Exp(-riskFree * timeToExp);
  400.     double expDiv = Math.Exp(-dividend * timeToExp);
  401.  
  402.     return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  403.       baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  404.   }
  405.  
  406.   [SqlFunction()]
  407.   public static System.Data.SqlTypes.SqlDouble FBS_PUT02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  408.   {
  409.     return (float)BS_PUT(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  410.   }
  411.  
  412.   [SqlProcedure(Name = "BS_PUT02")]
  413.   public static void BS_PUT02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  414.   {
  415.     double result = BS_PUT(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  416.     SqlConnection conn = new SqlConnection("Context Connection=true");
  417.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  418.     cmd.Parameters.Add(new SqlParameter("@result", result));
  419.     conn.Open();
  420.  
  421.     SqlDataReader rdr = cmd.ExecuteReader();
  422.     SqlContext.Pipe.Send(rdr);
  423.  
  424.     rdr.Close();
  425.     conn.Close();
  426.   }
  427.   /// <summary>
  428.   /// Расчет премии по опциону Put
  429.   /// </summary>
  430.   /// <param name="baseActive">Значение базового актива</param>
  431.   /// <param name="strike">Страйк опциона</param>
  432.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  433.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  434.   /// <param name="deviation">Стандартное отклонение</param>
  435.   /// <returns>Премию опциона Put</returns>
  436.   public static double BS_PUT(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  437.   {
  438.     double dividend = 0;
  439.     double expRate = Math.Exp(-riskFree * timeToExp);
  440.     double expDiv = Math.Exp(-dividend * timeToExp);
  441.  
  442.     return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  443.       baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  444.   }
  445.  
  446.   [SqlFunction()]
  447.   public static System.Data.SqlTypes.SqlDouble FBS_PUT03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  448.   {
  449.     return (float)BS_PUT(baseActive, strike, timeToExp, riskFree, deviation);
  450.   }
  451.  
  452.   [SqlProcedure(Name = "BS_PUT03")]
  453.   public static void BS_PUT03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  454.   {
  455.     double result = BS_PUT(baseActive, strike, timeToExp, riskFree, deviation);
  456.     SqlConnection conn = new SqlConnection("Context Connection=true");
  457.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  458.     cmd.Parameters.Add(new SqlParameter("@result", result));
  459.     conn.Open();
  460.  
  461.     SqlDataReader rdr = cmd.ExecuteReader();
  462.     SqlContext.Pipe.Send(rdr);
  463.  
  464.     rdr.Close();
  465.     conn.Close();
  466.   }
  467.   /// <summary>
  468.   /// Расчет премии по опциону Put
  469.   /// </summary>
  470.   /// <param name="baseActive">Значение базового актива</param>
  471.   /// <param name="strike">Страйк опциона</param>
  472.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  473.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  474.   /// <param name="deviation">Стандартное отклонение</param>
  475.   /// <returns>Премию опциона Put</returns>
  476.   public static double BS_PUT(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  477.   {
  478.     double timeToExp = dayToExp / dayInYear;
  479.     double dividend = 0;
  480.     double expRate = Math.Exp(-riskFree * timeToExp);
  481.     double expDiv = Math.Exp(-dividend * timeToExp);
  482.  
  483.     return strike * expRate * Statistic.N(-d2(baseActive, strike, timeToExp, riskFree, deviation, dividend)) -
  484.       baseActive * expDiv * Statistic.N(-d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  485.   }
  486.  
  487.   [SqlFunction()]
  488.   public static System.Data.SqlTypes.SqlDouble FBS_PUT04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  489.   {
  490.     return (float)BS_PUT(baseActive, strike, dayToExp, riskFree, deviation);
  491.   }
  492.  
  493.   [SqlProcedure(Name = "BS_PUT04")]
  494.   public static void BS_PUT04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  495.   {
  496.     double result = BS_PUT(baseActive, strike, dayToExp, riskFree, deviation);
  497.     
  498.     SqlConnection conn = new SqlConnection("Context Connection=true");
  499.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  500.     cmd.Parameters.Add(new SqlParameter("@result", result));
  501.     conn.Open();
  502.  
  503.     SqlDataReader rdr = cmd.ExecuteReader();
  504.     SqlContext.Pipe.Send(rdr);
  505.  
  506.     rdr.Close();
  507.     conn.Close();
  508.   }
  509.  
  510.   #endregion
  511.  
  512.   #region BS_CDELTA
  513.   /// <summary>
  514.   /// Расчет дельты опциона Call
  515.   /// </summary>
  516.   /// <param name="baseActive">Значение базового актива</param>
  517.   /// <param name="strike">Страйк опциона</param>
  518.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  519.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  520.   /// <param name="deviation">Стандартное отклонение</param>
  521.   /// <param name="dividend">Размер дивиденда по акциям</param>
  522.   /// <returns>Дельта опциона Call</returns>
  523.   public static double BS_CDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  524.   {
  525.     return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  526.   }
  527.  
  528.   [SqlFunction()]
  529.   public static System.Data.SqlTypes.SqlDouble FBS_CDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  530.   {
  531.     return (float)BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  532.   }
  533.  
  534.   [SqlProcedure(Name = "BS_CDELTA01")]
  535.   public static void BS_CDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  536.   {
  537.     double result = BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  538.     SqlConnection conn = new SqlConnection("Context Connection=true");
  539.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  540.     cmd.Parameters.Add(new SqlParameter("@result", result));
  541.     conn.Open();
  542.  
  543.     SqlDataReader rdr = cmd.ExecuteReader();
  544.     SqlContext.Pipe.Send(rdr);
  545.  
  546.     rdr.Close();
  547.     conn.Close();
  548.   }
  549.   /// <summary>
  550.   /// Расчет дельты опциона Call
  551.   /// </summary>
  552.   /// <param name="baseActive">Значение базового актива</param>
  553.   /// <param name="strike">Страйк опциона</param>
  554.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  555.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  556.   /// <param name="deviation">Стандартное отклонение</param>
  557.   /// <param name="dividend">Размер дивиденда по акциям</param>
  558.   /// <returns>Дельта опциона Call</returns>
  559.   public static double BS_CDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  560.   {
  561.     double timeToExp = dayToExp / dayInYear;
  562.     return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  563.   }
  564.  
  565.   [SqlFunction()]
  566.   public static System.Data.SqlTypes.SqlDouble FBS_CDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  567.   {
  568.     return (float)BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  569.   }
  570.  
  571.   [SqlProcedure(Name = "BS_CDELTA02")]
  572.   public static void BS_CDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  573.   {
  574.     double result = BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  575.     SqlConnection conn = new SqlConnection("Context Connection=true");
  576.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  577.     cmd.Parameters.Add(new SqlParameter("@result", result));
  578.     conn.Open();
  579.  
  580.     SqlDataReader rdr = cmd.ExecuteReader();
  581.     SqlContext.Pipe.Send(rdr);
  582.  
  583.     rdr.Close();
  584.     conn.Close();
  585.   }
  586.  
  587.   /// <summary>
  588.   /// Расчет дельты опциона Call
  589.   /// </summary>
  590.   /// <param name="baseActive">Значение базового актива</param>
  591.   /// <param name="strike">Страйк опциона</param>
  592.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  593.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  594.   /// <param name="deviation">Стандартное отклонение</param>
  595.   /// <returns>Дельта опциона Call</returns>
  596.  &;nbsp;public static double BS_CDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  597.   {
  598.     double dividend = 0;
  599.     return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  600.   }
  601.  
  602.   [SqlFunction()]
  603.   public static System.Data.SqlTypes.SqlDouble FBS_CDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  604.   {
  605.     return (float)BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation);
  606.   }
  607.  
  608.   [SqlProcedure(Name = "BS_CDELTA03")]
  609.   public static void
    /font> BS_CDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  610.   {
  611.     double result = BS_CDELTA(baseActive, strike, timeToExp, riskFree, deviation);
  612.     SqlConnection conn = new SqlConnection("Context Connection=true");
  613.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  614.     cmd.Parameters.Add(new SqlParameter("@result", result));
  615.     conn.Open();
  616.  
  617.     SqlDataReader rdr = cmd.ExecuteReader();
  618.     SqlContext.Pipe.Send(rdr);
  619.  
  620.     rdr.Close();
  621.     conn.Close();
  622.   }
  623.  
  624.   /// <summary>
  625.   /// Расчет дельты опциона Call
  626.   /// </summary>
  627.   /// <param name="baseActive">Значение базового актива</param>
  628.   /// <param name="strike">Страйк опциона</param>
  629.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  630.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  631.   /// <param name="deviation">Стандартное отклонение</param>
  632.   /// <returns>Дельта опциона Call</returns>
  633.   public static double BS_CDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  634.   {
  635.     double timeToExp = dayToExp / dayInYear;
  636.     double dividend = 0;
  637.     return Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend));
  638.   }
  639.  
  640.   [SqlFunction()]
  641.   public static System.Data.SqlTypes.SqlDouble FBS_CDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  642.   {
  643.     return (float)BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation);
  644.   }
  645.  
  646.   [SqlProcedure(Name = "BS_CDELTA04")]
  647.   public static void BS_CDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  648.   {
  649.     double result = BS_CDELTA(baseActive, strike, dayToExp, riskFree, deviation);
  650.     SqlConnection conn = new SqlConnection("Context Connection=true");
  651.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  652.     cmd.Parameters.Add(new SqlParameter("@result", result));
  653.     conn.Open();
  654.  
  655.     SqlDataReader rdr = cmd.ExecuteReader();
  656.     SqlContext.Pipe.Send(rdr);
  657.  
  658.     rdr.Close();
  659.     conn.Close();
  660.   }
  661.  
  662.   #endregion
  663.  
  664.   #region BS_PDELTA
  665.   /// <summary>
  666.   /// Расчет дельты опциона Put
  667.   /// </summary>
  668.   /// <param name="baseActive">Значение базового актива</param>
  669.   /// <param name="strike">Страйк опциона</param>
  670.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  671.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  672.   /// <param name="deviation">Стандартное отклонение</param>
  673.   /// <param name="dividend">Размер дивиденда по акциям</param>
  674.   /// <returns>Дельта опциона Put</returns>
  675.   public static double BS_PDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  676.   {
  677.     return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1);
  678.   }
  679.  
  680.   [SqlFunction()]
  681.   public static System.Data.SqlTypes.SqlDouble FBS_PDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  682.   {
  683.     return (float)BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  684.   }
  685.  
  686.   [SqlProcedure(Name = "BS_PDELTA01")]
  687.   public static void BS_PDELTA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  688.   {
  689.     double result = BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  690.     SqlConnection conn = new SqlConnection("Context Connection=true");
  691.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  692.     cmd.Parameters.Add(new SqlParameter("@result", result));
  693.     conn.Open();
  694.  
  695.     SqlDataReader rdr = cmd.ExecuteReader();
  696.     SqlContext.Pipe.Send(rdr);
  697.  
  698.     rdr.Close();
  699.     conn.Close();
  700.   }
  701.  
  702.   /// <summary>
  703.   /// Расчет дельты опциона Put
  704.   /// </summary>
  705.   /// <param name="baseActive">Значение базового актива</param>
  706.   /// <param name="strike">Страйк опциона</param>
  707.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  708.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  709.   /// <param name="deviation">Стандартное отклонение</param>
  710.   /// <param name="dividend">Размер дивиденда по акциям</param>
  711.   /// <returns>Дельта опциона Put</returns>
  712.   public static double BS_PDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  713.   {
  714.     double timeToExp = dayToExp / dayInYear;
  715.     return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1);
  716.   }
  717.  
  718.   [SqlFunction()]
  719.   public static System.Data.SqlTypes.SqlDouble FBS_PDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  720.   {
  721.     return (float)BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  722.   }
  723.  
  724.   [SqlProcedure(Name = "BS_PDELTA02")]
  725.   public static void BS_PDELTA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  726.   {
  727.     double result = BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  728.     SqlConnection conn = new SqlConnection("Context Connection=true");
  729.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  730.     cmd.Parameters.Add(new SqlParameter("@result", result));
  731.     conn.Open();
  732.  
  733.     SqlDataReader rdr = cmd.ExecuteReader();
  734.     SqlContext.Pipe.Send(rdr);
  735.  
  736.     rdr.Close();
  737.     conn.Close();
  738.   }
  739.  
  740.   /// <summary>
  741.   /// Расчет дельты опциона Put
  742.   /// </summary>
  743.   /// <param name="baseActive">Значение базового актива</param>
  744.   /// <param name="strike">Страйк опциона</param>
  745.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  746.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  747.   /// <param name="deviation">Стандартное отклонение</param>
  748.   /// <returns>Дельта опциона Put</returns>
  749.   public static double BS_PDELTA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  750.   {
  751.     double dividend = 0;
  752.     return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1);
  753.   }
  754.  
  755.   [SqlFunction()]
  756.   public static System.Data.SqlTypes.SqlDouble FBS_PDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  757.   {
  758.     return (float)BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation);
  759.   }
  760.  
  761.   [SqlProcedure(Name = "BS_PDELTA03")]
  762.   public static void BS_PDELTA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  763.   {
  764.     double result = BS_PDELTA(baseActive, strike, timeToExp, riskFree, deviation);
  765.     SqlConnection conn = new SqlConnection("Context Connection=true");
  766.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  767.     cmd.Parameters.Add(new SqlParameter("@result", result));
  768.     conn.Open();
  769.  
  770.     SqlDataReader rdr = cmd.ExecuteReader();
  771.     SqlContext.Pipe.Send(rdr);
  772.  
  773.     rdr.Close();
  774.     conn.Close();
  775.   }
  776.  
  777.   /// <summary>
  778.   /// Расчет дельты опциона Put
  779.   /// </summary>
  780.   /// <param name="baseActive">Значение базового актива</param>
  781.   /// <param name="strike">Страйк опциона</param>
  782.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  783.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  784.   /// <param name="deviation">Стандартное отклонение</param>
  785.   /// <returns>Дельта опциона Put</returns>
  786.   public static double BS_PDELTA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  787.   {
  788.     double timeToExp = dayToExp / dayInYear;
  789.     double dividend = 0;
  790.     return (Statistic.N(d1(baseActive, strike, timeToExp, riskFree, deviation, dividend)) - 1);
  791.   }
  792.  
  793.   [SqlFunction()]
  794.   public static System.Data.SqlTypes.SqlDouble FBS_PDELTA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  795.   {
  796.     return (float)BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation);
  797.   }
  798.  
  799.   [SqlProcedure(Name = "BS_PDELTA04")]
  800.   public static void BS_PDELTA04(double baseActive, double strike, ;int dayToExp, double riskFree, double deviation)
  801.   {
  802.     double result = BS_PDELTA(baseActive, strike, dayToExp, riskFree, deviation);
  803.     SqlConnection conn = new SqlConnection("Context Connection=true");
  804.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  805.     cmd.Parameters.Add(new SqlParameter("@result", result));
  806.     conn.Open();
  807.  
  808.     SqlDataReader rdr = cmd.ExecuteReader();
  809.     SqlContext.Pipe.Send(rdr);
  810.  
  811.     rdr.Close();
  812.     conn.Close();
  813.   }
  814.  
  815.   #endregion
  816.  
  817.   #region BS_CTHETA
  818.   /// <summary>
  819.   /// Расчет временного распада для текущего момента времени у опциона Call
  820.   /// </summary>
  821.   /// <param name="baseActive">Значение базового актива</param>
  822.   /// <param name="strike">Страйк опциона</param>
  823.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  824.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  825.   /// <param name="deviation">Стандартное отклонение</param>
  826.   /// <param name="dividend">Размер дивиденда по акциям</param>
  827.   /// <returns>Временной распад опциона Call</returns>
  828.   public static double BS_CTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  829.   {
  830.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  831.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  832.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  833.     double expRate = Math.Exp(-riskFree * timeToExp);
  834.  
  835.     return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2));
  836.   }
  837.  
  838.   [SqlFunction()]
  839.   public static System.Data.SqlTypes.SqlDouble FBS_CTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  840.   {
  841.     return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  842.   }
  843.  
  844.   [SqlProcedure(Name = "BS_CTHETA01")]
  845.   public static void BS_CTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  846.   {
  847.     double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  848.     SqlConnection conn = new SqlConnection("Context Connection=true");
  849.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  850.     cmd.Parameters.Add(new SqlParameter("@result", result));
  851.     conn.Open();
  852.  
  853.     SqlDataReader rdr = cmd.ExecuteReader();
  854.     SqlContext.Pipe.Send(rdr);
  855.  
  856.     rdr.Close();
  857.     conn.Close();
  858.   }
  859.  
  860.   /// <summary>
  861.   /// Расчет временного распада для текущего момента времени у опциона Call
  862.   /// </summary>
  863.   /// <param name="baseActive">Значение базового актива</param>
  864.   /// <param name="strike">Страйк опциона</param>
  865.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  866.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  867.   /// <param name="deviation">Стандартное отклонение</param>
  868.   /// <param name="dividend">Размер дивиденда по акциям</param>
  869.   /// <returns>Временной распад опциона Call</returns>
  870.   public static double BS_CTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  871.   {
  872.     double timeToExp = dayToExp / dayInYear;
  873.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  874.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  875.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  876.     double expRate = Math.Exp(-riskFree * timeToExp);
  877.  
  878.     return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2));
  879.   }
  880.  
  881.   [SqlFunction()]
  882.   public static System.Data.SqlTypes.SqlDouble FBS_CTHETA02(double baseActive, double strike, int timeToExp, double riskFree, double deviation, double dividend)
  883.   {
  884.     return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  885.   }
  886.  
  887.   [SqlProcedure(Name = "BS_CTHETA02")]
  888.   public static void BS_CTHETA02(double baseActive, double strike, int timeToExp, double riskFree, double deviation, double dividend)
  889.   {
  890.     double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  891.     SqlConnection conn = new SqlConnection("Context Connection=true");
  892.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  893.     cmd.Parameters.Add(new SqlParameter("@result", result));
  894.     conn.Open();
  895.  
  896.     SqlDataReader rdr = cmd.ExecuteReader();
  897.     SqlContext.Pipe.Send(rdr);
  898.  
  899.     rdr.Close();
  900.     conn.Close();
  901.   }
  902.  
  903.   /// <summary>
  904.   /// Расчет временного распада для текущего момента времени у опциона Call
  905.   /// </summary>
  906.   /// <param name="baseActive">Значение базового актива</param>
  907.   /// <param name="strike">Страйк опциона</param>
  908.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  909.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  910.   /// <param name="deviation">Стандартное отклонение</param>
  911.   /// <returns>Временной распад опциона Call</returns>
  912.   public static double BS_CTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  913.   {
  914.     double dividend = 0;
  915.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  916.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  917.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  918.     double expRate = Math.Exp(-riskFree * timeToExp);
  919.  
  920.     return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2));
  921.   }
  922.  
  923.   [SqlFunction()]
  924.   public static System.Data.SqlTypes.SqlDouble FBS_CTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  925.   {
  926.     return (float)BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation);
  927.   }
  928.  
  929.   [SqlProcedure(Name = "BS_CTHETA03")]
  930.   public static void BS_CTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  931.   {
  932.     double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation);
  933.     SqlConnection conn = new SqlConnection("Context Connection=true");
  934.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  935.     cmd.Parameters.Add(new SqlParameter("@result", result));
  936.     conn.Open();
  937.  
  938.     SqlDataReader rdr = cmd.ExecuteReader();
  939.     SqlContext.Pipe.Send(rdr);
  940.  
  941.     rdr.Close();
  942.     conn.Close();
  943.   }
  944.  
  945.   /// <summary>
  946.   /// Расчет временного распада для текущего момента времени у опциона Call
  947.   /// </summary>
  948.   /// <param name="baseActive">Значение базового актива</param>
  949.   /// <param name="strike">Страйк опциона</param>
  950.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  951.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  952.   /// <param name="deviation">Стандартное отклонение</param>
  953.   /// <returns>Временной распад опциона Call</returns>
  954.   public static double BS_CTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  955.   {
  956.     double timeToExp = dayToExp / dayInYear;
  957.     double dividend = 0;
  958.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  959.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  960.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  961.     double expRate = Math.Exp(-riskFree * timeToExp);
  962.  
  963.     return timeDif * (baseActive * deviation * nd11 / (2 * Math.Sqrt(timeToExp)) + strike * riskFree * expRate * Statistic.N(var_d2));
  964.   }
  965.  
  966.   [SqlFunction()]
  967.   public static System.Data.SqlTypes.SqlDouble FBS_CTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  968.   {
  969.     return (float)BS_CTHETA(baseActive, strike, dayToExp, riskFree, deviation);
  970.   }
  971.  
  972.   [SqlProcedure(Name = "BS_CTHETA04")]
  973.   public static void BS_CTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  974.   {
  975.     double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation);
  976.     SqlConnection conn = new SqlConnection("Context Connection=true");
  977.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  978.     cmd.Parameters.Add(new SqlParameter("@result", result));
  979.     conn.Open();
  980.  
  981.     SqlDataReader rdr = cmd.ExecuteReader();
  982.     SqlContext.Pipe.Send(rdr);
  983.  
  984.     rdr.Close();
  985.     conn.Close();
  986.   }
  987.  
  988.  
  989.   #endregion
  990.  
  991.   #region BS_PTHETA
  992.   /// <summary>
  993.   /// Расчет временного распада для текущего момента времени у опциона Put
  994.   /// </summary>
  995.   /// <param name="baseActive">Значение базового актива</param>
  996.   /// <param name="strike">Страйк опциона</param>
  997.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  998.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  999.   /// <param name="deviation">Стандартное отклонение</param>
  1000.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1001.   /// <returns>Временной распад опциона Put</returns>
  1002.   public static double BS_PTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1003.   {
  1004.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1005.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1006.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1007.     double expRate = Math.Exp(-riskFree * timeToExp);
  1008.  
  1009.     return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) -
  1010.     timeDif * strike * riskFree * expRate;
  1011.   }
  1012.   
  1013.   [SqlFunction()]
  1014.   public static System.Data.SqlTypes.SqlDouble FBS_PTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1015.   {
  1016.     return (float)BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1017.   }
  1018.  
  1019.   [SqlProcedure(Name = "BS_PTHETA01")]
  1020.   public static void BS_PTHETA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1021.   {
  1022.     double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1023.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1024.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1025.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1026.     conn.Open();
  1027.  
  1028.     SqlDataReader rdr = cmd.ExecuteReader();
  1029.     SqlContext.Pipe.Send(rdr);
  1030.  
  1031.     rdr.Close();
  1032.     conn.Close();
  1033.   }
  1034.  
  1035.  
  1036.   /// <summary>
  1037.   /// Расчет временного распада для текущего момента времени у опциона Put
  1038.   /// </summary>
  1039.   /// <param name="baseActive">Значение базового актива</param>
  1040.   /// <param name="strike">Страйк опциона</param>
  1041.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1042.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1043.   /// <param name="deviation">Стандартное отклонение</param>
  1044.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1045.   /// <returns>Временной распад опциона Put</returns>
  1046.   public static double BS_PTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1047.   {
  1048.     double timeToExp = dayToExp / dayInYear;
  1049.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1050.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1051.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1052.     double expRate = Math.Exp(-riskFree * timeToExp);
  1053.  
  1054.     return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) -
  1055.     timeDif * strike * riskFree * expRate;
  1056.   }
  1057.  
  1058.   [SqlFunction()]
  1059.   public static System.Data.SqlTypes.SqlDouble FBS_PTHETA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1060.   {
  1061.     return (float)BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1062.   }
  1063.  
  1064.   [SqlProcedure(Name = "BS_PTHETA02")]
  1065.   public static void BS_PTHETA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1066.   {
  1067.     double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1068.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1069.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1070.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1071.     conn.Open();
  1072.  
  1073.     SqlDataReader rdr = cmd.ExecuteReader();
  1074.     SqlContext.Pipe.Send(rdr);
  1075.  
  1076.     rdr.Close();
  1077.     conn.Close();
  1078.   }
  1079.   /// <summary>
  1080.   /// Расчет временного распада для текущего момента времени у опциона Put
  1081.   /// </summary>
  1082.   /// <param name="baseActive">Значение базового актива</param>
  1083.   /// <param name="strike">Страйк опциона</param>
  1084.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1085.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1086.   /// <param name="deviation">Стандартное отклонение</param>
  1087.   /// <returns>Временной распад опциона Put</returns>
  1088.   public static double BS_PTHETA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1089.   {
  1090.     double dividend = 0;
  1091.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1092.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1093.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1094.     double expRate = Math.Exp(-riskFree * timeToExp);
  1095.  
  1096.     return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) -
  1097.     timeDif * strike * riskFree * expRate;
  1098.   }
  1099.  
  1100.   [SqlFunction()]
  1101.   public static System.Data.SqlTypes.SqlDouble FBS_PTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1102.   {
  1103.     return (float)BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation);
  1104.   }
  1105.  
  1106.   [SqlProcedure(Name = "BS_PTHETA03")]
  1107.   public static void BS_PTHETA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1108.   {
  1109.     double result = BS_PTHETA(baseActive, strike, timeToExp, riskFree, deviation);
  1110.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1111.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1112.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1113.     conn.Open();
  1114.  
  1115.     SqlDataReader rdr = cmd.ExecuteReader();
  1116.     SqlContext.Pipe.Send(rdr);
  1117.  
  1118.     rdr.Close();
  1119.     conn.Close();
  1120.   }
  1121.  
  1122.   /// <summary>
  1123.   /// Расчет временного распада для текущего момента времени у опциона Put
  1124.   /// </summary>
  1125.   /// <param name="baseActive">Значение базового актива</param>
  1126.   /// <param name="strike">Страйк опциона</param>
  1127.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1128.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1129.   /// <param name="deviation">Стандартное отклонение</param>
  1130.   /// <returns>Временной распад опциона Put</returns>
  1131.   ///
  1132.   public static double BS_PTHETA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1133.   {
  1134.     double timeToExp = dayToExp / dayInYear;
  1135.     double dividend = 0;
  1136.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1137.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1138.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1139.     double expRate = Math.Exp(-riskFree * timeToExp);
  1140.  
  1141.     return BS_CTHETA(baseActive, strike, timeToExp, riskFree, deviation, dividend) -
  1142.     timeDif * strike * riskFree * expRate;
  1143.   }
  1144.  
  1145.   [SqlFunction()]
  1146.   public static System.Data.SqlTypes.SqlDouble FBS_PTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1147.   {
  1148.     return (float)BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation);
  1149.   }
  1150.  
  1151.   [SqlProcedure(Name = "BS_PTHETA04")]
  1152.   public static void BS_PTHETA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1153.   {
  1154.     double result = BS_PTHETA(baseActive, strike, dayToExp, riskFree, deviation);
  1155.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1156.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1157.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1158.     conn.Open();
  1159.  
  1160.     SqlDataReader rdr = cmd.ExecuteReader();
  1161.     SqlContext.Pipe.Send(rdr);
  1162.  
  1163.     rdr.Close();
  1164.     conn.Close();
  1165.   }
  1166.  
  1167.   #endregion
  1168.  
  1169.   #region BS_CVEGA
  1170.   /// <summary>
  1171.   /// Расчет влияния волатильности на премию опциона Call
  1172.   /// </summary>
  1173.   /// <param name="baseActive">Значение базового актива</param>
  1174.   /// <param name="strike">Страйк опциона</param>
  1175.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1176.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1177.   /// <param name="deviation">Стандартное отклонение</param>
  1178.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1179.   /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns>
  1180.   public static double BS_CVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1181.   {
  1182.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1183.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1184.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1185.  
  1186.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1187.   }
  1188.  
  1189.   [SqlFunction()]
  1190.   public static System.Data.SqlTypes.SqlDouble FBS_CVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1191.   {
  1192.     return (float)BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1193.   }
  1194.  
  1195.   [SqlProcedure(Name = "BS_CVEGA01")]
  1196.   public static void BS_CVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1197.   {
  1198.     double result = BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1199.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1200.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1201.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1202.     conn.Open();
  1203.  
  1204.     SqlDataReader rdr = cmd.ExecuteReader();
  1205.     SqlContext.Pipe.Send(rdr);
  1206.  
  1207.     rdr.Close();
  1208.     conn.Close();
  1209.   }
  1210.  
  1211.   /// <summary>
  1212.   /// Расчет влияния волатильности на премию опциона Call
  1213.   /// </summary>
  1214.   /// <param name="baseActive">Значение базового актива</param>
  1215.   /// <param name="strike">Страйк опциона</param>
  1216.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1217.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1218.   /// <param name="deviation">Стандартное отклонение</param>
  1219.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1220.   /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns>
  1221.   public static double BS_CVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1222.   {
  1223.     double timeToExp = dayToExp / dayInYear;
  1224.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1225.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1226.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1227.  
  1228.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1229.   }
  1230.  
  1231.   [SqlFunction()]
  1232.   public static System.Data.SqlTypes.SqlDouble FBS_CVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1233.   {
  1234.     return (float)BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1235.   }
  1236.  
  1237.   [SqlProcedure(Name = "BS_CVEGA02")]
  1238.   public static void BS_CVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1239.   {
  1240.     double result = BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1241.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1242.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1243.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1244.     conn.Open();
  1245.  
  1246.     SqlDataReader rdr = cmd.ExecuteReader();
  1247.     SqlContext.Pipe.Send(rdr);
  1248.  
  1249.     rdr.Close();
  1250.     conn.Close();
  1251.   }
  1252.  
  1253.   /// <summary>
  1254.   /// Расчет влияния волатильности на премию опциона Call
  1255.   /// </summary>
  1256.   /// <param name="baseActive">Значение базового актива</param>
  1257.   /// <param name="strike">Страйк опциона</param>
  1258.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1259.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1260.   /// <param name="deviation">Стандартное отклонение</param>
  1261.   /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns>
  1262.   public static double BS_CVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1263.   {
  1264.     double dividend = 0;
  1265.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1266.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1267.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1268.  
  1269.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1270.   }
  1271.  
  1272.   [SqlFunction()]
  1273.   public static System.Data.SqlTypes.SqlDouble FBS_CVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1274.   {
  1275.     return (float)BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation);
  1276.   }
  1277.  
  1278.   [SqlProcedure(Name = "BS_CVEGA03")]
  1279.   public static void BS_CVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1280.   {
  1281.     double result = BS_CVEGA(baseActive, strike, timeToExp, riskFree, deviation);
  1282.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1283.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1284.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1285.     conn.Open();
  1286.  
  1287.     SqlDataReader rdr = cmd.ExecuteReader();
  1288.     SqlContext.Pipe.Send(rdr);
  1289.  
  1290.     rdr.Close();
  1291.     conn.Close();
  1292.   }
  1293.  
  1294.   /// <summary>
  1295.   /// Расчет влияния волатильности на премию опциона Call
  1296.   /// </summary>
  1297.   /// <param name="baseActive">Значение базового актива</param>
  1298.   /// <param name="strike">Страйк опциона</param>
  1299.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1300.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1301.   /// <param name="deviation">Стандартное отклонение</param>
  1302.   /// <returns>На сколько изменится премия опциона Call при изменение волатильности на 1%</returns>
  1303.   public static double BS_CVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1304.   {
  1305.     double timeToExp = dayToExp / dayInYear;
  1306.     double dividend = 0;
  1307.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1308.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1309.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1310.  
  1311.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1312.   }
  1313.  
  1314.   [SqlFunction()]
  1315.   public static System.Data.SqlTypes.SqlDouble FBS_CVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1316.   {
  1317.     return (float)BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation);
  1318.   }
  1319.  
  1320.   [SqlProcedure(Name = "BS_CVEGA04")]
  1321.   public static void BS_CVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1322.   {
  1323.     double result = BS_CVEGA(baseActive, strike, dayToExp, riskFree, deviation);
  1324.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1325.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1326.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1327.     conn.Open();
  1328.  
  1329.     SqlDataReader rdr = cmd.ExecuteReader();
  1330.     SqlContext.Pipe.Send(rdr);
  1331.  
  1332.     rdr.Close();
  1333.     conn.Close();
  1334.   }
  1335.  
  1336.   #endregion
  1337.  
  1338.   #region BS_PVEGA
  1339.   /// <summary>
  1340.   /// Расчет влияния волатильности на премию опциона Put
  1341.   /// </summary>
  1342.   /// <param name="baseActive">Значение базового актива</param>
  1343.   /// <param name="strike">Страйк опциона</param>
  1344.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1345.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1346.   /// <param name="deviation">Стандартное отклонение</param>
  1347.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1348.   /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns>
  1349.   public static double BS_PVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1350.   {
  1351.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1352.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1353.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1354.  
  1355.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1356.   }
  1357.  
  1358.   [SqlFunction()]
  1359.   public static System.Data.SqlTypes.SqlDouble FBS_PVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1360.   {
  1361.     return (float)BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1362.   }
  1363.  
  1364.   [SqlProcedure(Name = "BS_PVEGA01")]
  1365.   public static void BS_PVEGA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1366.   {
  1367.     double result = BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1368.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1369.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1370.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1371.     conn.Open();
  1372.  
  1373.     SqlDataReader rdr = cmd.ExecuteReader();
  1374.     SqlContext.Pipe.Send(rdr);
  1375.  
  1376.     rdr.Close();
  1377.     conn.Close();
  1378.   }
  1379.  
  1380.   /// <summary>
  1381.   /// Расчет влияния волатильности на премию опциона Put
  1382.   /// </summary>
  1383.   /// <param name="baseActive">Значение базового актива</param>
  1384.   /// <param name="strike">Страйк опциона</param>
  1385.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1386.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1387.   /// <param name="deviation">Стандартное отклонение</param>
  1388.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1389.   /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns>
  1390.   public static double BS_PVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1391.   {
  1392.     double timeToExp = dayToExp / dayInYear;
  1393.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1394.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1395.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1396.  
  1397.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1398.   }
  1399.  
  1400.   [SqlFunction()]
  1401.   public static System.Data.SqlTypes.SqlDouble FBS_PVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1402.   {
  1403.     return (float)BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1404.   }
  1405.  
  1406.   [SqlProcedure(Name = "BS_PVEGA02")]
  1407.   public static void BS_PVEGA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1408.   {
  1409.     double result = BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1410.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1411.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1412.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1413.     conn.Open();
  1414.  
  1415.     SqlDataReader rdr = cmd.ExecuteReader();
  1416.     SqlContext.Pipe.Send(rdr);
  1417.  
  1418.     rdr.Close();
  1419.     conn.Close();
  1420.   }
  1421.  
  1422.   /// <summary>
  1423.   /// Расчет влияния волатильности на премию опциона Put
  1424.   /// </summary>
  1425.   /// <param name="baseActive">Значение базового актива</param>
  1426.   /// <param name="strike">Страйк опциона</param>
  1427.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1428.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1429.   /// <param name="deviation">Стандартное отклонение</param>
  1430.   /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns>
  1431.   public static double BS_PVEGA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1432.   {
  1433.     double dividend = 0;
  1434.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1435.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1436.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1437.  
  1438.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1439.   }
  1440.  
  1441.   [SqlFunction()]
  1442.   public static System.Data.SqlTypes.SqlDouble FBS_PVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1443.   {
  1444.     return (float)BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation);
  1445.   }
  1446.  
  1447.   [SqlProcedure(Name = "BS_PVEGA03")]
  1448.   public static void BS_PVEGA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1449.   {
  1450.     double result = BS_PVEGA(baseActive, strike, timeToExp, riskFree, deviation);
  1451.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1452.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1453.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1454.     conn.Open();
  1455.  
  1456.     SqlDataReader rdr = cmd.ExecuteReader();
  1457.     SqlContext.Pipe.Send(rdr);
  1458.  
  1459.     rdr.Close();
  1460.     conn.Close();
  1461.   }
  1462.  
  1463.   /// <summary>
  1464.   /// Расчет влияния волатильности на премию опциона Put
  1465.   /// </summary>
  1466.   /// <param name="baseActive">Значение базового актива</param>
  1467.   /// <param name="strike">Страйк опциона</param>
  1468.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1469.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1470.   /// <param name="deviation">Стандартное отклонение</param>
  1471.   /// <returns>На сколько изменится премия опциона Put при изменение волатильности на 1%</returns>
  1472.   public static double BS_PVEGA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1473.   {
  1474.     double timeToExp = dayToExp / dayInYear;
  1475.     double dividend = 0;
  1476.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1477.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1478.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1479.  
  1480.     return vegaDif * baseActive * nd11 * Math.Sqrt(timeToExp);
  1481.   }
  1482.  
  1483.   [SqlFunction()]
  1484.   public static System.Data.SqlTypes.SqlDouble FBS_PVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1485.   {
  1486.     return (float)BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation);
  1487.   }
  1488.  
  1489.   [SqlProcedure(Name = "BS_PVEGA04")]
  1490.   public static void BS_PVEGA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1491.   {
  1492.     double result = BS_PVEGA(baseActive, strike, dayToExp, riskFree, deviation);
  1493.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1494.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1495.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1496.     conn.Open();
  1497.  
  1498.     SqlDataReader rdr = cmd.ExecuteReader();
  1499.     SqlContext.Pipe.Send(rdr);
  1500.  
  1501.     rdr.Close();
  1502.     conn.Close();
  1503.   }
  1504.  
  1505.   #endregion
  1506.  
  1507.   #region BS_CGAMMA
  1508.   /// <summary>
  1509.   /// Расчет скорости изменения дельты опциона Call
  1510.   /// </summary>
  1511.   /// <param name="baseActive">Значение базового актива</param>
  1512.   /// <param name="strike">Страйк опциона</param>
  1513.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1514.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1515.   /// <param name="deviation">Стандартное отклонение</param>
  1516.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1517.   /// <returns>Скорость изменения дельты опциона Call</returns>
  1518.   public static double BS_CGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1519.   {
  1520.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1521.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1522.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1523.  
  1524.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1525.   }
  1526.  
  1527.   [SqlFunction()]
  1528.   public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1529.   {
  1530.     return (float)BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1531.   }
  1532.  
  1533.   [SqlProcedure(Name = "BS_CGAMMA01")]
  1534.   public static void BS_CGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1535.   {
  1536.     double result = BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1537.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1538.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1539.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1540.     conn.Open();
  1541.  
  1542.     SqlDataReader rdr = cmd.ExecuteReader();
  1543.     SqlContext.Pipe.Send(rdr);
  1544.  
  1545.     rdr.Close();
  1546.     conn.Close();
  1547.   }
  1548.  
  1549.   /// <summary>
  1550.   /// Расчет скорости изменения дельты опциона Call
  1551.   /// </summary>
  1552.   /// <param name="baseActive">Значение базового актива</param>
  1553.   /// <param name="strike">Страйк опциона</param>
  1554.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1555.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1556.   /// <param name="deviation">Стандартное отклонение</param>
  1557.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1558.   /// <returns>Скорость изменения дельты опциона Call</returns>
  1559.   public static double BS_CGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1560.   {
  1561.     double timeToExp = dayToExp / dayInYear;
  1562.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1563.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1564.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1565.  
  1566.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1567.   }
  1568.  
  1569.   [SqlFunction()]
  1570.   public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1571.   {
  1572.     return (float)BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1573.   }
  1574.  
  1575.   [SqlProcedure(Name = "BS_CGAMMA02")]
  1576.   public static void BS_CGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1577.   {
  1578.     double result = BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1579.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1580.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1581.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1582.     conn.Open();
  1583.  
  1584.     SqlDataReader rdr = cmd.ExecuteReader();
  1585.     SqlContext.Pipe.Send(rdr);
  1586.  
  1587.     rdr.Close();
  1588.     conn.Close();
  1589.   }
  1590.  
  1591.  
  1592.   /// <summary>
  1593.   /// Расчет скорости изменения дельты опциона Call
  1594.   /// </summary>
  1595.   /// <param name="baseActive">Значение базового актива</param>
  1596.   /// <param name="strike">Страйк опциона</param>
  1597.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1598.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1599.   /// <param name="deviation">Стандартное отклонение</param>
  1600.   /// <returns>Скорость изменения дельты опциона Call</returns>
  1601.   public static double BS_CGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1602.   {
  1603.     double dividend = 0;
  1604.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1605.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1606.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1607.  
  1608.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1609.   }
  1610.  
  1611.   [SqlFunction()]
  1612.   public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1613.   {
  1614.     return (float)BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation);
  1615.   }
  1616.  
  1617.   [SqlProcedure(Name = "BS_CGAMMA03")]
  1618.   public static void BS_CGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1619.   {
  1620.     double result = BS_CGAMMA(baseActive, strike, timeToExp, riskFree, deviation);
  1621.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1622.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1623.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1624.     conn.Open();
  1625.  
  1626.     SqlDataReader rdr = cmd.ExecuteReader();
  1627.     SqlContext.Pipe.Send(rdr);
  1628.  
  1629.     rdr.Close();
  1630.     conn.Close();
  1631.   }
  1632.  
  1633.   /// <summary>
  1634.   /// Расчет скорости изменения дельты опциона Call
  1635.   /// </summary>
  1636.   /// <param name="baseActive">Значение базового актива</param>
  1637.   /// <param name="strike">Страйк опциона</param>
  1638.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1639.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1640.   /// <param name="deviation">Стандартное отклонение</param>
  1641.   /// <returns>Скорость изменения дельты опциона Call</returns>
  1642.   public static double BS_CGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1643.   {
  1644.     double timeToExp = dayToExp / dayInYear;
  1645.     double dividend = 0;
  1646.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1647.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1648.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1649.  
  1650.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1651.   }
  1652.   [SqlFunction()]
  1653.   public static System.Data.SqlTypes.SqlDouble FBS_CGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1654.   {
  1655.     return (float)BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation);
  1656.   }
  1657.  
  1658.   [SqlProcedure(Name = "BS_CGAMMA04")]
  1659.   public static void BS_CGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1660.   {
  1661.     double result = BS_CGAMMA(baseActive, strike, dayToExp, riskFree, deviation);
  1662.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1663.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1664.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1665.     conn.Open();
  1666.  
  1667.     SqlDataReader rdr = cmd.ExecuteReader();
  1668.     SqlContext.Pipe.Send(rdr);
  1669.  
  1670.     rdr.Close();
  1671.     conn.Close();
  1672.   }
  1673.  
  1674.   #endregion
  1675.  
  1676.   #region BS_PGAMMA
  1677.   /// <summary>
  1678.   /// Расчет скорости изменения дельты опциона Put
  1679.   /// </summary>
  1680.   /// <param name="baseActive">Значение базового актива</param>
  1681.   /// <param name="strike">Страйк опциона</param>
  1682.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1683.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1684.   /// <param name="deviation">Стандартное отклонение</param>
  1685.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1686.   /// <returns>Скорость изменения дельты опциона Put</returns>
  1687.   public static double BS_PGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1688.   {
  1689.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1690.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1691.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1692.  
  1693.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1694.   }
  1695.  
  1696.   [SqlFunction()]
  1697.   public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1698.   {
  1699.     return (float)BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1700.   }
  1701.  
  1702.   [SqlProcedure(Name = "BS_PGAMMA01")]
  1703.   public static void BS_PGAMMA01(double baseActive, double strike, double timeToExp, double riskFree, double deviation, double dividend)
  1704.   {
  1705.     double result = BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1706.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1707.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1708.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1709.     conn.Open();
  1710.  
  1711.     SqlDataReader rdr = cmd.ExecuteReader();
  1712.     SqlContext.Pipe.Send(rdr);
  1713.  
  1714.     rdr.Close();
  1715.     conn.Close();
  1716.   }
  1717.  
  1718.   /// <summary>
  1719.   /// Расчет скорости изменения дельты опциона Put
  1720.   /// </summary>
  1721.   /// <param name="baseActive">Значение базового актива</param>
  1722.   /// <param name="strike">Страйк опциона</param>
  1723.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1724.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1725.   /// <param name="deviation">Стандартное отклонение</param>
  1726.   /// <param name="dividend">Размер дивиденда по акциям</param>
  1727.   /// <returns>Скорость изменения дельты опциона Put</returns>
  1728.   public static double BS_PGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1729.   {
  1730.     double timeToExp = dayToExp / dayInYear;
  1731.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1732.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1733.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1734.  
  1735.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1736.   }
  1737.  
  1738.   [SqlFunction()]
  1739.   public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1740.   {
  1741.     return (float)BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1742.   }
  1743.  
  1744.   [SqlProcedure(Name = "BS_PGAMMA02")]
  1745.   public static void BS_PGAMMA02(double baseActive, double strike, int dayToExp, double riskFree, double deviation, double dividend)
  1746.   {
  1747.     double result = BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation, dividend);
  1748.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1749.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1750.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1751.     conn.Open();
  1752.  
  1753.     SqlDataReader rdr = cmd.ExecuteReader();
  1754.     SqlContext.Pipe.Send(rdr);
  1755.  
  1756.     rdr.Close();
  1757.     conn.Close();
  1758.   }
  1759.  
  1760.   /// <summary>
  1761.   /// Расчет скорости изменения дельты опциона Put
  1762.   /// </summary>
  1763.   /// <param name="baseActive">Значение базового актива</param>
  1764.   /// <param name="strike">Страйк опциона</param>
  1765.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1766.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1767.   /// <param name="deviation">Стандартное отклонение</param>
  1768.   /// <returns>Скорость изменения дельты опциона Put</returns>
  1769.   public static double BS_PGAMMA(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1770.   {
  1771.     double dividend = 0;
  1772.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1773.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1774.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1775.  
  1776.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1777.   }
  1778.  
  1779.   [SqlFunction()]
  1780.   public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1781.   {
  1782.     return (float)BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation);
  1783.   }
  1784.  
  1785.   [SqlProcedure(Name = "BS_PGAMMA03")]
  1786.   public static void BS_PGAMMA03(double baseActive, double strike, double timeToExp, double riskFree, double deviation)
  1787.   {
  1788.     double result = BS_PGAMMA(baseActive, strike, timeToExp, riskFree, deviation);
  1789.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1790.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1791.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1792.     conn.Open();
  1793.  
  1794.     SqlDataReader rdr = cmd.ExecuteReader();
  1795.     SqlContext.Pipe.Send(rdr);
  1796.  
  1797.     rdr.Close();
  1798.     conn.Close();
  1799.   }
  1800.  
  1801.   /// <summary>
  1802.   /// Расчет скорости изменения дельты опциона Put
  1803.   /// </summary>
  1804.   /// <param name="baseActive">Значение базового актива</param>
  1805.   /// <param name="strike">Страйк опциона</param>
  1806.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1807.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1808.   /// <param name="deviation">Стандартное отклонение</param>
  1809.   /// <returns>Скорость изменения дельты опциона Put</returns>
  1810.   public static double BS_PGAMMA(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1811.   {
  1812.     double timeToExp = dayToExp / dayInYear;
  1813.     double dividend = 0;
  1814.     double var_d1 = d1(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1815.     double var_d2 = d2(baseActive, strike, timeToExp, riskFree, deviation, dividend);
  1816.     double nd11 = Math.Exp(-var_d1 * var_d1 / 2.0) / Math.Sqrt(2 * Math.PI);
  1817.  
  1818.     return gammaDif * nd11 / (baseActive * deviation * Math.Sqrt(timeToExp));
  1819.   }
  1820.  
  1821.   [SqlFunction()]
  1822.   public static System.Data.SqlTypes.SqlDouble FBS_PGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1823.   {
  1824.     return (float)BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation);
  1825.   }
  1826.  
  1827.   [SqlProcedure(Name = "BS_PGAMMA04")]
  1828.   public static void BS_PGAMMA04(double baseActive, double strike, int dayToExp, double riskFree, double deviation)
  1829.   {
  1830.     double result = BS_PGAMMA(baseActive, strike, dayToExp, riskFree, deviation);
  1831.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1832.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1833.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1834.     conn.Open();
  1835.  
  1836.     SqlDataReader rdr = cmd.ExecuteReader();
  1837.     SqlContext.Pipe.Send(rdr);
  1838. <
    i> 

  1839.     rdr.Close();
  1840.     conn.Close();
  1841.   }
  1842.  
  1843.   #endregion
  1844.  
  1845.   #region BS_IV
  1846.   /// <summary>
  1847.   /// Расчет подразумеваемой волатильности (Implied Volatility)
  1848.   /// </summary>
  1849.   /// <param name="ot">Тип опциона Call или Put</param>
  1850.   /// <param name="baseActive">Значение базового актива</param>
  1851.   /// <param name="strike">Страйк опциона</param>
  1852.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  1853.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1854.   /// <param name="premium">Премия по опциону</param>
  1855.   /// <param name="deviation">Стандартное отклонение</param>
  1856.   /// <returns>Подразумеваевая волатильность</returns>
  1857.   public static double BS_IV(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend)
  1858.   {
  1859.     return BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium, dividend);
  1860.   }
  1861.   public static double BS_IV(OptionType ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend)
  1862.   {
  1863.  
  1864.     double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000]
  1865.     double z = zLeft;        //Стартовую точку берем на левом крае интервала
  1866.     int n = 200;          //Количество итераций
  1867.  
  1868.     //Проверяем для какого опциона мы определяем волатильность
  1869.     //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим
  1870.     if ((int)ot == 1)
  1871.     {//Это Call
  1872.       if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0, dividend)) return 0;
  1873.     }
  1874.     else
  1875.     {
  1876.       //Это Put
  1877.       if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0, dividend)) return 0;
  1878.     }
  1879.  
  1880.     //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами
  1881.     if ((int)ot == 1)
  1882.     {
  1883.       //Это Call
  1884.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft, dividend) > premium)
  1885.         zLeft /= 2;
  1886.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight, dividend) < premium)
  1887.         zRight *= 2;
  1888.  
  1889.     }
  1890.     else
  1891.     {
  1892.       //Это Put
  1893.       //Это Call
  1894.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft, dividend) > premium)
  1895.         zLeft /= 2;
  1896.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight, dividend) < premium)
  1897.         zRight *= 2;
  1898.     }
  1899.  
  1900.     //Начинаем поиск методом деления отрезка пополам в получившемся интервале
  1901.     if ((int)ot == 1)
  1902.     {
  1903.       //Это Call
  1904.       for (int i = 0; i < n; i++)
  1905.       {
  1906.         z = (zLeft + zRight) / 2;
  1907.         if (BS_CALL(baseActive, strike, timeToExp, riskFree, z, dividend) > premium)
  1908.           zRight = z;
  1909.         else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z, dividend) < premium)
  1910.           zLeft = z;
  1911.       }
  1912.     }
  1913.     else
  1914.     {
  1915.       //Это Put
  1916.       for (int i = 0; i < n; i++)
  1917.       {
  1918.         z = (zLeft + zRight) / 2;
  1919.         if (BS_PUT(baseActive, strike, timeToExp, riskFree, z, dividend) > premium)
  1920.           zRight = z;
  1921.         else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z, dividend) < premium)
  1922.           zLeft = z;
  1923.       }
  1924.     }
  1925.  
  1926.     if (double.IsInfinity(z))
  1927.       return z = 0;
  1928.     return z;
  1929.   }
  1930.  
  1931.   [SqlFunction()]
  1932.   public static System.Data.SqlTypes.SqlDouble FBS_IV01(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend)
  1933.   {
  1934.     return (float)BS_IV(ot, baseActive, strike, timeToExp, riskFree, premium, dividend);
  1935.   }
  1936.  
  1937.   [SqlProcedure(Name = "BS_IV01")]
  1938.   public static void BS_IV01(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium, double dividend)
  1939.   {
  1940.     double result = BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium, dividend);
  1941.     SqlConnection conn = new SqlConnection("Context Connection=true");
  1942.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  1943.     cmd.Parameters.Add(new SqlParameter("@result", result));
  1944.     conn.Open();
  1945.  
  1946.     SqlDataReader rdr = cmd.ExecuteReader();
  1947.     SqlContext.Pipe.Send(rdr);
  1948.  
  1949.     rdr.Close();
  1950.     conn.Close();
  1951.   }
  1952.  
  1953.   /// <summary>
  1954.   /// Расчет подразумеваемой волатильности (Implied Volatility)
  1955.   /// </summary>
  1956.   /// <param name="ot">Тип опциона Call или Put</param>
  1957.   /// <param name="baseActive">Значение базового актива</param>
  1958.   /// <param name="strike">Страйк опциона</param>
  1959.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  1960.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  1961.   /// <param name="premium">Премия по опциону</param>
  1962.   /// <param name="deviation">Стандартное отклонение</param>
  1963.   /// <returns>Подразумеваевая волатильность</returns>
  1964.   public static double BS_IV(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend)
  1965.   {
  1966.     return BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium, dividend);
  1967.   }
  1968.   public static double BS_IV(OptionType ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend)
  1969.   {
  1970.     double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000]
  1971.     double z = zLeft;        //Стартовую точку берем на левом крае интервала
  1972.     int n = 200;          //Количество итераций
  1973.  
  1974.     //Проверяем для какого опциона мы определяем волатильность
  1975.     //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим
  1976.     if ((int)ot == 1)
  1977.     {//Это Call
  1978.       if (premium <= BS_CALL(baseActive, strike, dayToExp, riskFree, 0, dividend)) return 0;
  1979.     }
  1980.     else
  1981.     {
  1982.       //Это Put
  1983.       if (premium <= BS_PUT(baseActive, strike, dayToExp, riskFree, 0, dividend)) return 0;
  1984.     }
  1985.  
  1986.     //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами
  1987.     if ((int)ot == 1)
  1988.     {
  1989.       //Это Call
  1990.       while (BS_CALL(baseActive, strike, dayToExp, riskFree, zLeft, dividend) > premium)
  1991.         zLeft /= 2;
  1992.       while (BS_CALL(baseActive, strike, dayToExp, riskFree, zRight, dividend) < premium)
  1993.         zRight *= 2;
  1994.  
  1995.     }
  1996.     else
  1997.     {
  1998.       //Это Put
  1999.       //Это Call
  2000.       while (BS_PUT(baseActive, strike, dayToExp, riskFree, zLeft, dividend) > premium)
  2001.         zLeft /= 2;
  2002.       while (BS_PUT(baseActive, strike, dayToExp, riskFree, zRight, dividend) < premium)
  2003.         zRight *= 2;
  2004.     }
  2005.  
  2006.     //Начинаем поиск методом деления отрезка пополам в получившемся интервале
  2007.     if ((int)ot == 1)
  2008.     {
  2009.       //Это Call
  2010.       for (int i = 0; i < n; i++)
  2011.       {
  2012.         z = (zLeft + zRight) / 2;
  2013.         if (BS_CALL(baseActive, strike, dayToExp, riskFree, z, dividend) > premium)
  2014.           zRight = z;
  2015.         else if (BS_CALL(baseActive, strike, dayToExp, riskFree, z, dividend) < premium)
  2016.           zLeft = z;
  2017.       }
  2018.     }
  2019.     else
  2020.     {
  2021.       //Это Put
  2022.       for (int i = 0; i < n; i++)
  2023.       {
  2024.         z = (zLeft + zRight) / 2;
  2025.         if (BS_PUT(baseActive, strike, dayToExp, riskFree, z, dividend) > premium)
  2026.           zRight = z;
  2027.         else if (BS_PUT(baseActive, strike, dayToExp, riskFree, z, dividend) < premium)
  2028.           zLeft = z;
  2029.       }
  2030.     }
  2031.  
  2032.     if (double.IsInfinity(z))
  2033.       return z = 0;
  2034.     return z;
  2035.   }
  2036.  
  2037.   [SqlFunction()]
  2038.   public static System.Data.SqlTypes.SqlDouble FBS_IV02(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend)
  2039.   {
  2040.     return (float)BS_IV(ot, baseActive, strike, dayToExp, riskFree, premium, dividend);
  2041.   }
  2042.  
  2043.   [SqlProcedure(Name = "BS_IV02")]
  2044.   public static void BS_IV02(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium, double dividend)
  2045.   {
  2046.     double result = BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium, dividend);
  2047.     SqlConnection conn = new SqlConnection("Context Connection=true");
  2048.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  2049.     cmd.Parameters.Add(new SqlParameter("@result", result));
  2050.     conn.Open();
  2051.  
  2052.     SqlDataReader rdr = cmd.ExecuteReader();
  2053.     SqlContext.Pipe.Send(rdr);
  2054.  
  2055.     rdr.Close();
  2056.     conn.Close();
  2057.   }
  2058.  
  2059.   /// <summary>
  2060.   /// Расчет подразумеваемой волатильности (Implied Volatility)
  2061.   /// </summary>
  2062.   /// <param name="ot">Тип опциона Call или Put</param>
  2063.   /// <param name="baseActive">Значение базового актива</param>
  2064.   /// <param name="strike">Страйк опциона</param>
  2065.   /// <param name="timeToExp">Время до экспирации (сколько лет осталось)</param>
  2066.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  2067.   /// <param name="premium">Премия по опциону</param>
  2068.   /// <param name="deviation">Стандартное отклонение</param>
  2069.   /// <returns>Подразумеваевая волатильность</returns>
  2070.   public static double BS_IV(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium)
  2071.   {
  2072.     return BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium);
  2073.   }
  2074.   public static double BS_IV(OptionType ot, double baseActive, double strike, double timeToExp, double riskFree, double premium)
  2075.   {
  2076.  
  2077.     double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000]
  2078.     double z = zLeft;        //Стартовую точку берем на левом крае интервала
  2079.     int n = 200;          //Количество итераций
  2080.  
  2081.     //Проверяем для какого опциона мы определяем волатильность
  2082.     //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим
  2083.     if ((int)ot == 1)
  2084.     {//Это Call
  2085.       if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0)) return 0;
  2086.     }
  2087.     else
  2088.     {
  2089.       //Это Put
  2090.       if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0)) return 0;
  2091.     }
  2092.  
  2093.     //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами
  2094.     if ((int)ot == 1)
  2095.     {
  2096.       //Это Call
  2097.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft) > premium)
  2098.         zLeft /= 2;
  2099.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight) < premium)
  2100.         zRight *= 2;
  2101.  
  2102.     }
  2103.     else
  2104.     {
  2105.       //Это Put
  2106.       //Это Call
  2107.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft) > premium)
  2108.         zLeft /= 2;
  2109.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight) < premium)
  2110.         zRight *= 2;
  2111.     }
  2112.  
  2113.     //Начинаем поиск методом деления отрезка пополам в получившемся интервале
  2114.     if ((int)ot == 1)
  2115.     {
  2116.       //Это Call
  2117.       for (int i = 0; i < n; i++)
  2118.       {
  2119.         z = (zLeft + zRight) / 2;
  2120.         if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) > premium)
  2121.           zRight = z;
  2122.         else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) < premium)
  2123.           zLeft = z;
  2124.       }
  2125.     }
  2126.     else
  2127.     {
  2128.       //Это Put
  2129.       for (int i = 0; i < n; i++)
  2130.       {
  2131.         z = (zLeft + zRight) / 2;
  2132.         if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) > premium)
  2133.           zRight = z;
  2134.         else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) < premium)
  2135.           zLeft = z;
  2136.       }
  2137.     }
  2138.  
  2139.     if (double.IsInfinity(z))
  2140.       return z = 0;
  2141.     return z;
  2142.   }
  2143.  
  2144.   [SqlFunction()]
  2145.   public static System.Data.SqlTypes.SqlDouble FBS_IV03(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium)
  2146.   {
  2147.     return (float)BS_IV(ot, baseActive, strike, timeToExp, riskFree, premium);
  2148.   }
  2149.  
  2150.   [SqlProcedure(Name = "BS_IV03")]
  2151.   public static void BS_IV03(int ot, double baseActive, double strike, double timeToExp, double riskFree, double premium)
  2152.   {
  2153.     double result = BS_IV((OptionType)ot, baseActive, strike, timeToExp, riskFree, premium);
  2154.     SqlConnection conn = new SqlConnection("Context Connection=true");
  2155.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  2156.     cmd.Parameters.Add(new SqlParameter("@result", result));
  2157.     conn.Open();
  2158.  
  2159.     SqlDataReader rdr = cmd.ExecuteReader();
  2160.     SqlContext.Pipe.Send(rdr);
  2161.  
  2162.     rdr.Close();
  2163.     conn.Close();
  2164.   }
  2165.   /// <summary>
  2166.   /// Расчет подразумеваемой волатильности (Implied Volatility)
  2167.   /// </summary>
  2168.   /// <param name="ot">Тип опциона Call или Put</param>
  2169.   /// <param name="baseActive">Значение базового актива</param>
  2170.   /// <param name="strike">Страйк опциона</param>
  2171.   /// <param name="dayToExp">Дней до экспирации (сколько дней осталось)</param>
  2172.   /// <param name="riskFree">Безрисковай процентная ставка</param>
  2173.   /// <param name="premium">Премия по опциону</param>
  2174.   /// <param name="deviation">Стандартное отклонение</param>
  2175.   /// <returns>Подразумеваевая волатильность</returns>
  2176.   [SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "BS_IV04")]
  2177.   public static double BS_IV(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium)
  2178.   {
  2179.     return BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium);
  2180.   }
  2181.   public static double BS_IV(OptionType ot, double baseActive, double strike, int dayToExp, double riskFree, double premium)
  2182.   {
  2183.     double timeToExp = dayToExp / dayInYear;
  2184.     double zLeft = 0, zRight = 1000;//Начинаем перебор волатильности, в диапазоне от [0; 1000]
  2185.     double z = zLeft;        //Стартовую точку берем на левом крае интервала
  2186.     int n = 200;          //Количество итераций
  2187.  
  2188.     //Проверяем для какого опциона мы определяем волатильность
  2189.     //Если Премия оказывается меньше чем премия с нулевой волатильностью, то выходим
  2190.     if ((int)ot == 1)
  2191.     {//Это Call
  2192.       if (premium <= BS_CALL(baseActive, strike, timeToExp, riskFree, 0)) return 0;
  2193.     }
  2194.     else
  2195.     {
  2196.       //Это Put
  2197.       if (premium <= BS_PUT(baseActive, strike, timeToExp, riskFree, 0)) return 0;
  2198.     }
  2199.  
  2200.     //Осуществляем методом увеличения отрезка пополам, если мы не угадали с границами
  2201.     if ((int)ot == 1)
  2202.     {
  2203.       //Это Call
  2204.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zLeft) > premium)
  2205.         zLeft /= 2;
  2206.       while (BS_CALL(baseActive, strike, timeToExp, riskFree, zRight) < premium)
  2207.         zRight *= 2;
  2208.  
  2209.     }
  2210.     else
  2211.     {
  2212.       //Это Put
  2213.       //Это Call
  2214.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zLeft) > premium)
  2215.         zLeft /= 2;
  2216.       while (BS_PUT(baseActive, strike, timeToExp, riskFree, zRight) < premium)
  2217.         zRight *= 2;
  2218.     }
  2219.  
  2220.     //Начинаем поиск методом деления отрезка пополам в получившемся интервале
  2221.     if ((int)ot == 1)
  2222.     {
  2223.       //Это Call
  2224.       for (int i = 0; i < n; i++)
  2225.       {
  2226.         z = (zLeft + zRight) / 2;
  2227.         if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) > premium)
  2228.           zRight = z;
  2229.         else if (BS_CALL(baseActive, strike, timeToExp, riskFree, z) < premium)
  2230.           zLeft = z;
  2231.       }
  2232.     }
  2233.     else
  2234.     {
  2235.       //Это Put
  2236.       for (int i = 0; i < n; i++)
  2237.       {
  2238.         z = (zLeft + zRight) / 2;
  2239.         if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) > premium)
  2240.           zRight = z;
  2241.         else if (BS_PUT(baseActive, strike, timeToExp, riskFree, z) < premium)
  2242.           zLeft = z;
  2243.       }
  2244.     }
  2245.  
  2246.     if (double.IsInfinity(z))
  2247.       return z = 0;
  2248.     return z;
  2249.   }
  2250.   
  2251.   [SqlFunction()]
  2252.   public static System.Data.SqlTypes.SqlDouble FBS_IV04(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium)
  2253.   {
  2254.     return (float)BS_IV(ot, baseActive, strike, dayToExp, riskFree, premium);
  2255.   }
  2256.  
  2257.   [SqlProcedure(Name = "BS_IV04")]
  2258.   public static void BS_IV04(int ot, double baseActive, double strike, int dayToExp, double riskFree, double premium)
  2259.   {
  2260.     double result = BS_IV((OptionType)ot, baseActive, strike, dayToExp, riskFree, premium);
  2261.     SqlConnection conn = new SqlConnection("Context Connection=true");
  2262.     SqlCommand cmd = new SqlCommand(@"SELECT @result as result", conn);
  2263.     cmd.Parameters.Add(new SqlParameter("@result", result));
  2264.     conn.Open();
  2265.  
  2266.     SqlDataReader rdr = cmd.ExecuteReader();
  2267.     SqlContext.Pipe.Send(rdr);
  2268.  
  2269.     rdr.Close();
  2270.     conn.Close();
  2271.   }
  2272.   #endregion
  2273. }

* This source code was highlighted with Source Code Highlighter.

Интересная статья? Поделитесь ею пожалуйста с другими:

Опубликовать в Twitter Написать в Facebook Поделиться ВКонтакте В Google Buzz Записать себе в LiveJournal Показать В Моем Мире В дневник на LI.RU Поделиться ссылкой в Моем Круге

Приглашаю присоединиться ко мне:

Follow Me Я в FaceBook Я ВКонтакте или подпишитесь на обновления блога по RSS

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

*

*


Можно использовать следующие HTML-теги и атрибуты: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>