public Task <QuotationResult> CalculatePremiums(QuotationInput quoteparams)
{
try
{
return(Task.Run(() =>
{
double d1 = 0.0;
double d2 = 0.0;
QuotationResult quotes = new QuotationResult();
double S = double.Parse(quoteparams.StockPrice.Replace(".", ","));
double K = double.Parse(quoteparams.StrikePrice.Replace(".", ","));
double T = double.Parse(quoteparams.TimeToMaturity.Replace(".", ","));
double r = double.Parse(quoteparams.InterestRate.Replace(".", ","));
double v = double.Parse(quoteparams.Volatility.Replace(".", ","));
d1 = Math.Round((Math.Log(S / K) + (r + v * v / 2.0) * T) / v / Math.Sqrt(T), 4);
d2 = Math.Round(d1 - v * Math.Sqrt(T), 4);
quotes.D1 = d1;
quotes.D2 = d2;
quotes.CallPremium = Math.Round(S * CumulativeNormDistFunction(d1) - K * Math.Exp(-r * T) * CumulativeNormDistFunction(d2), 4);
quotes.PutPremium = Math.Round(K * Math.Exp(-r * T) * CumulativeNormDistFunction(-d2) - S * CumulativeNormDistFunction(-d1), 4);
return quotes;
}));
}
catch (Exception ex)
{
throw;
}
}
List <PointF> GenerateRandNormal(int n)
{
if (n % 2 == 1)
{
n++;
}
List <PointF> points = new List <PointF>(n);
for (int i = 0; i < n / 2; i++)
{
do
{
double u = 2 * rnd.NextDouble() - 1;
double v = 2 * rnd.NextDouble() - 1;
double s = u * u + v * v;
if (s < 1)
{
s = Math.Sqrt(-2 * Math.Log(s) / s);
points.Add(new PointF(i, (float)(u * s)));
points.Add(new PointF(i + 1, (float)(v * s)));
break;
}
} while (true);
}
return(points);
}
// Normalize coefficients à la Jenkins & Traub's RPOLY.
// Normalization is done by scaling coefficients with a power of 2, so
// that all the bits in the mantissa remain unchanged.
// Use the infinity norm (max(sum(abs(a)…)) to determine the appropriate
// scale factor. See @hkrish in #1087#issuecomment-231526156
private static Real GetNormalizationFactor(params Real[] values)
{
var norm = values.Max();
return(norm != 0 && (norm < 1e-8 || norm > 1e8)
? Math.Pow(2, -Math.Round(Math.Log(norm)))
: 0f);
}
public double NextGaussian()
{
const double mean = 0, stdDev = 1;
double u1 = 1.0 - rand.NextDouble();
double u2 = 1.0 - rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
return(mean + stdDev * randStdNormal);
}
/// <summary>
/// Evaluates the delta wrt the discount rate R.
/// </summary>
/// <param name="amount">The amount for that period.</param>
/// <param name="paymentDiscountFactor">The payment discount factor.</param>
/// <param name="periodAsTimesPerYear">the compounding year fraction.</param>
/// <param name="curveYearFraction">The time to payment year fraction.</param>
/// <returns></returns>
public static double Delta1ForAnAmount(double amount, double paymentDiscountFactor,
double periodAsTimesPerYear, double curveYearFraction)
{
if (curveYearFraction == 0.0)
{
return(0.0);
}
var rate = (double)Math.Log((double)paymentDiscountFactor) / curveYearFraction;
var temp = periodAsTimesPerYear * -rate;
var result = amount * paymentDiscountFactor * curveYearFraction / (1 + temp) / 10000.0;
return(result);
}
/// <summary>
/// Converts a discount factor to a compounding zero rate.
/// </summary>
///<param name="discountFactor"></param>
///<param name="yearFraction"></param>
///<param name="compoundingPeriod"></param>
///<returns></returns>
public static double DiscountFactorToZeroRate(double discountFactor, double yearFraction,
double compoundingPeriod)
{
double result;
if (compoundingPeriod == 0)
{
result = -Math.Log(discountFactor) / yearFraction;
}
else
{
double power = -compoundingPeriod / yearFraction;
result = (Math.Pow(discountFactor, power) - 1.0) / compoundingPeriod;
}
return(result);
}
private static double[] DiscountFactorHelper(double[] times, double[] dfs)
{
var zeroes = new List <double>();
var dfsLength = dfs.Length;
if (times.Length == dfsLength)
{
var zero = 0.0;
for (var i = dfsLength - 1; i >= 0; i--)
{
if (times[i] != 0)
{
zero = -Math.Log(dfs[i]) / times[i];
}
zeroes.Add(zero);
}
}
return(zeroes.ToArray());
}
private static double[] DiscountFactorHelper(DateTime baseDate, IEnumerable <DateTime> dates, double[] dfs)
{
var zeroes = new List <double>();
var dfsLength = dfs.Length;
var times = PointCurveHelper(baseDate, dates);
if (times.Length == dfsLength)
{
var zero = 0.0;
for (var i = dfsLength - 1; i >= 0; i--)
{
if (times[i] != 0)
{
zero = -Math.Log(dfs[i]) / times[i];
}
zeroes.Add(zero);
}
}
return(zeroes.ToArray());
}
public static double QuadraticBezierLength(Vector2D p0, Vector2D p1, Vector2D p2)
{
Vector2D a = new Vector2D();
Vector2D b = new Vector2D();
a.X = p0.X - 2 * p1.X + p2.X;
a.Y = p0.Y - 2 * p1.Y + p2.Y;
b.X = 2 * p1.X - 2 * p0.X;
b.Y = 2 * p1.Y - 2 * p0.Y;
var A = 4 * (a.X * a.X + a.Y * a.Y);
var B = 4 * (a.X * b.X + a.Y * b.Y);
var C = b.X * b.X + b.Y * b.Y;
var Sabc = 2 * SysMath.Sqrt(A + B + C);
var A_2 = SysMath.Sqrt(A);
var A_32 = 2 * A * A_2;
var C_2 = 2 * SysMath.Sqrt(C);
var BA = B / A_2;
return((A_32 * Sabc + A_2 * B * (Sabc - C_2) + (4 * C * A - B * B) * SysMath.Log((2 * A_2 + BA + Sabc) / (BA + C_2))) / (4 * A_32));
}
/// <summary>
/// Finds the logarithm of a number with the specified base.
/// </summary>
/// <param name="number">Number greater than 0.</param>
/// <param name="logBase">Base of the logarithm in the range [0,1),(1, ∞).</param>
/// <returns name="log">Logarithm of the number.</returns>
/// <search>logarithm,ld,lg</search>
public static double Log(double number, double logBase)
{
return(CSMath.Log(number, logBase));
}
/// <summary>
/// Finds the natural logarithm of a number in the range (0, ∞).
/// </summary>
/// <param name="number">Number greater than 0.</param>
/// <returns name="log">Natural log of the number.</returns>
/// <search>natural,logarithm,ln</search>
public static double Log(double number)
{
return(CSMath.Log(number));
}
// Logarithm to base N
public static double LogN(double x, double n)
{
return(MathObj.Log(x) / MathObj.Log(n));
}
// Inverse Hyperbolic Cotangent
public static double HArccotan(double x)
{
return(MathObj.Log((x + 1) / (x - 1)) / 2);
}
public static double Log(double d) => Math.Log(d);
/// <summary>
/// Calculates a natural logarithm of dual number
/// </summary>
public static DualNumber Log(DualNumber value)
{
return(new DualNumber((float)SMath.Log(value.Value), value.Derivative / value.Value));
}
public static double NextPowerOfTwo(double n)
{
return((double)SysMath.Pow(2.0, SysMath.Ceiling(SysMath.Log(n, 2.0))));
}
public static double Log(double value)
{
return(CSMath.Log(value));
}
public static double Log(this int i)
{
return(SysMath.Log(i));
}
public static double Log(this double d)
{
return(SysMath.Log(d));
}
//IBundle
public object Property(Interpreter interpreter, Token token, object argument)
{
string propertyName = (string)argument;
//utility functions
Func <double, double, double> NthRoot = (b, e) => {
if (e % 1 != 0 || e <= 0)
{
throw new ErrorHandler.RuntimeError(token, "Exponent must be a whole number above 0");
}
return(CSMath.Pow(b, 1 / e));
};
Func <double, double> Asinh = (x) => CSMath.Log(x + CSMath.Sqrt(x * x + 1));
Func <double, double> Acosh = (x) => CSMath.Log(x + CSMath.Sqrt(x * x - 1));
Func <double, double> Atanh = (x) => CSMath.Log((1 + x) / (1 - x)) / 2;
switch (propertyName)
{
case "PI": return(3.14159265358979);
case "E": return(2.71828182845905);
case "Abs": return(new CallableArity1(this, CSMath.Abs));
case "Floor": return(new CallableArity1(this, CSMath.Floor));
case "Ceil": return(new CallableArity1(this, CSMath.Ceiling));
case "Round": return(new CallableArity1(this, CSMath.Round));
case "Pow": return(new CallableArity2(this, CSMath.Pow));
case "Root": return(new CallableArity2(this, NthRoot)); //doesn't exist in C# yet
case "Log": return(new CallableArity1(this, CSMath.Log));
case "Exp": return(new CallableArity1(this, CSMath.Exp));
case "Sin": return(new CallableArity1(this, CSMath.Sin));
case "Cos": return(new CallableArity1(this, CSMath.Cos));
case "Tan": return(new CallableArity1(this, CSMath.Tan));
case "Asin": return(new CallableArity1(this, CSMath.Asin));
case "Acos": return(new CallableArity1(this, CSMath.Acos));
case "Atan": return(new CallableArity1(this, CSMath.Atan));
case "Sinh": return(new CallableArity1(this, CSMath.Sinh));
case "Cosh": return(new CallableArity1(this, CSMath.Cosh));
case "Tanh": return(new CallableArity1(this, CSMath.Tanh));
case "Asinh": return(new CallableArity1(this, Asinh)); //doesn't exist in C# yet
case "Acosh": return(new CallableArity1(this, Acosh)); //doesn't exist in C# yet
case "Atanh": return(new CallableArity1(this, Atanh)); //doesn't exist in C# yet
default:
throw new ErrorHandler.RuntimeError(token, "Unknown property '" + propertyName + "'");
}
}
// Inverse Hyperbolic Sine
public static double HArcsin(double x)
{
return(MathObj.Log(x + MathObj.Sqrt(x * x + 1)));
}
public static Half Log(Half x,
Half y) =>
(Half)M.Log(x, y);
public static double Log(double value1, double value2)
{
return(CSMath.Log(value1, value2));
}
// Inverse Hyperbolic Cosine
public static double HArccos(double x)
{
return(MathObj.Log(x + MathObj.Sqrt(x * x - 1)));
}
public static Half Log(Half x) => (Half)M.Log(x);
// Inverse Hyperbolic Tangent
public static double HArctan(double x)
{
return(MathObj.Log((1 + x) / (1 - x)) / 2);
}
public static double Log(double d, double p) => Math.Log(d, p);
// Inverse Hyperbolic Secant
public static double HArcsec(double x)
{
return(MathObj.Log((MathObj.Sqrt(-x * x + 1) + 1) / x));
}
/// <summary>
/// Represents the log base two of e.
/// </summary>
/// <returns>System.Double.</returns>
public static double Log2E()
{
return(NMath.Log(NMath.E, 2));
}
// Inverse Hyperbolic Cosecant
public static double HArccosec(double x)
{
return(MathObj.Log((MathObj.Sign(x) * MathObj.Sqrt(x * x + 1) + 1) / x));
}
