public double GetEuroPrice(double volatility /*sigma*/)
{
// Return reasonable values for expired options
if (_maturity <= 0)
{
return(_callOrPut == LegType.Call
? _spotPrice - _strikePrice
: _strikePrice - _spotPrice);
}
double result;
if (_callOrPut == LegType.Call)
{
result = (_spotPrice * Math.Exp(-_divYield * _maturity) * NormDistribution.CumulativeDistribution(D1(volatility))) -
(_strikePrice * Math.Exp(-_interestRate * _maturity) * NormDistribution.CumulativeDistribution(D2(volatility)));
}
else
{
result = (_strikePrice * Math.Exp(-_interestRate * _maturity) *
NormDistribution.CumulativeDistribution(-D2(volatility))) -
(_spotPrice * Math.Exp(-_divYield * _maturity) * NormDistribution.CumulativeDistribution(-D1(volatility)));
}
return(result);
}
/// <summary>
/// Theta = first derivative of price with respect to time to expiration.
/// </summary>
/// <returns>theta of the option</returns>
public static double BlackScholesTheta(this EuropeanOption option, Date valueDate, double spot, double vol, double rate, double div)
{
var dist = new Normal();
var T = (double)(option._exerciseDate - valueDate) / 365;
double d1 = D1(spot, option._strike, vol, rate, div, T);
double d2 = D2(spot, option._strike, vol, rate, div, T);
double theta;
var flag = (double)option._putOrCall;
double t1 = (Math.Exp(-div * T) * spot * dist.Density(d1) * vol * 0.5) / Math.Sqrt(T);
double t2 = div * Math.Exp(-div * T) * spot * dist.CumulativeDistribution(flag * d1);
double t3 = rate * option._strike * Math.Exp(-rate * T) * dist.CumulativeDistribution(flag * d2);
if (option._putOrCall == PutOrCall.Call)
{
theta = -t1 + t2 - t3;
}
else
{
theta = -t1 - t2 + t3;
}
return(theta);
}
public static stats GenStats(List <List <round> > input)
{
List <double> faction_damage = new List <double> ();
List <double> asset_damage = new List <double> ();
foreach (var i in input)
{
faction_damage.Add(i.Select(e => Convert.ToDouble(e.direct_faction_damage)).Sum());
asset_damage.Add(i.Select(e => Convert.ToDouble(e.damage)).Sum());
}
var statistics = new DescriptiveStatistics(faction_damage);
var stats = new stats();
stats.faction_stats.Maximum = statistics.Maximum;
stats.faction_stats.Minimum = statistics.Minimum;
// stats.values.Median = statistics.Median;
stats.faction_stats.Mean = statistics.Mean;
stats.faction_stats.Variance = statistics.Variance;
stats.faction_stats.StandardDeviation = statistics.StandardDeviation;
stats.faction_stats.Kurtosis = statistics.Kurtosis;
stats.faction_stats.Skewness = statistics.Skewness;
statistics = new DescriptiveStatistics(asset_damage);
stats.asset_stats.Maximum = statistics.Maximum;
stats.asset_stats.Minimum = statistics.Minimum;
// stats.values.Median = statistics.Median;
stats.asset_stats.Mean = statistics.Mean;
stats.asset_stats.Variance = statistics.Variance;
stats.asset_stats.StandardDeviation = statistics.StandardDeviation;
stats.asset_stats.Kurtosis = statistics.Kurtosis;
stats.asset_stats.Skewness = statistics.Skewness;
Normal fac_normal = new Normal(stats.faction_stats.Mean, stats.faction_stats.StandardDeviation, Program.rand);
Normal asset_normal = new Normal(stats.asset_stats.Mean, stats.asset_stats.StandardDeviation, Program.rand);
for (int i = Convert.ToInt32(Math.Floor(stats.faction_stats.Minimum)); i < stats.faction_stats.Maximum; i++)
{
double item1 = fac_normal.CumulativeDistribution(i);
stats.faction_stats.normalized_dist.Add((i, item1));
}
for (int i = Convert.ToInt32(Math.Floor(stats.asset_stats.Minimum)); i < stats.asset_stats.Maximum; i++)
{
double item1 = fac_normal.CumulativeDistribution(i);
stats.asset_stats.normalized_dist.Add((i, item1));
}
return(stats);
}
/// <summary>
/// The Black the scholes formula
/// </summary>
/// <param name="putOrCall">put or call.</param>
/// <param name="K">The strike.</param>
/// <param name="T">The time to maturity in years.</param>
/// <param name="S">The underlying spot price.</param>
/// <param name="vol">The lognormal volatility of the underlying price.</param>
/// <param name="rate">The continuous rate used for drifting the underlying and discounting the payoff.</param>
/// <param name="div">The contiuous dividend yield that decreased the drift on the underlying.</param>
/// <returns></returns>
public static double BlackScholes(PutOrCall putOrCall, double K, double T, double S, double vol, double rate, double div)
{
Normal dist = new Normal();
double sigmaSqrtT = vol * Math.Sqrt(T);
double d1 = (1 / sigmaSqrtT) * (Math.Log(S / K) + rate - div + 0.5 * vol * vol);
double d2 = d1 - sigmaSqrtT;
double F = S * Math.Exp((rate - div) * T);
return(Math.Exp(-rate * T) * (F * dist.CumulativeDistribution(d1) - K * dist.CumulativeDistribution(d2)));
}
//public int CompareTo(NeuralPredictionModel other)
//{
// double otherAcc = other._accuracy;
// double thisAcc = _accuracy;
// double thisWeight = _score;
// double otherWeight = other._score;
// if (thisAcc != otherAcc)
// return otherAcc.CompareTo(thisAcc);
// else
// return otherWeight.CompareTo(thisWeight);
//}
//public override bool Equals(object obj)
//{
// var other = (NeuralPredictionModel)obj;
// if (other._accuracy == _accuracy)
// {
// if (other._score == _score)
// return true;
// else
// return false;
// }
// return false;
//}
//public override int GetHashCode()
//{
// return base.GetHashCode();
//}
//public static bool operator ==(NeuralPredictionModel x, NeuralPredictionModel y)
//{
// if (x._accuracy == y._accuracy)
// {
// if (x._score == y._score)
// return true;
// else
// return false;
// }
// return false;
//}
//public static bool operator !=(NeuralPredictionModel x, NeuralPredictionModel y)
//{
// if (x._accuracy == y._accuracy)
// {
// if (x._score == y._score)
// return false;
// else
// return true;
// }
// return true;
//}
//public static bool operator >(NeuralPredictionModel x, NeuralPredictionModel y)
//{
// if (x._accuracy > y._accuracy)
// return true;
// else
// {
// if (x._accuracy == y._accuracy)
// {
// if (x._score > y._score)
// return true;
// else
// return false;
// }
// else
// return false;
// }
//}
//public static bool operator <(NeuralPredictionModel x, NeuralPredictionModel y)
//{
// if (x._accuracy < y._accuracy)
// return true;
// else
// {
// if (x._accuracy == y._accuracy)
// {
// if (x._score < y._score)
// return true;
// else
// return false;
// }
// else
// return false;
// }
//}
/// <summary>
/// Finds the percentage of potential ratings that are above the potential renewal thresholds. Use Log values.
/// </summary>
/// <param name="Mean1">Projected Rating</param>
/// <param name="SD1">Standard Deviation for Projected Rating</param>
/// <param name="Mean2">Renewal Threshold Rating</param>
/// <param name="SD2">Standard Deviation for Renewal Thresholds</param>
/// <returns></returns>
double AreaOfOverlap(double Mean1, double SD1, double Mean2, double SD2)
{
//Find intersection points
double point1, point2;
var Distribution1 = new Normal(Mean1, SD1);
var Distribution2 = new Normal(Mean2, SD2);
if (SD1 * SD2 == 0)
{
return(0);
}
if (SD1 == SD2)
{
point1 = (Mean1 + Mean2) / 2;
point2 = point1;
}
else
{
//Find Square of each SD
double
Squared1 = Math.Pow(SD1, 2),
Squared2 = Math.Pow(SD2, 2);
//Then find part that will be positive and negative radical
var radical = Math.Sqrt(Math.Pow(Mean1 - Mean2, 2) + 2 * (Squared1 - Squared2) * Math.Log(SD1 / SD2));
point1 = (Mean2 * Squared1 - SD2 * (Mean1 * SD2 + SD1 * radical)) / (Squared1 - Squared2);
point2 = (Mean2 * Squared1 - SD2 * (Mean1 * SD2 + SD1 * -radical)) / (Squared1 - Squared2);
}
if (point1 == point2)
{
return((1 - Distribution1.CumulativeDistribution(point1)) * 2);
}
else
{
var min = Math.Min(point1, point2);
var max = Math.Max(point1, point2);
var beginning1 = Distribution1.CumulativeDistribution(min);
var beginning2 = Distribution2.CumulativeDistribution(min);
var middle1 = Distribution1.CumulativeDistribution(max) - Distribution1.CumulativeDistribution(min);
var middle2 = Distribution2.CumulativeDistribution(max) - Distribution2.CumulativeDistribution(min);
var end1 = 1 - Distribution1.CumulativeDistribution(max);
var end2 = 1 - Distribution2.CumulativeDistribution(max);
return(Math.Min(beginning1, beginning2) + Math.Min(middle1, middle2) + Math.Min(end1, end2));
}
}
// Helper function that calculates the probability of no tag read for a given
// amount of time T.
// Calculates 1 - (integral from 0 to T of gaussian+),
// where gaussian+ is when we consider only the positive values in the Gaussian
// distribution and then renormalize.
private double probNoTagRead(double T, bool visible)
{
Normal dist = this.coveredDist;
if (visible)
{
dist = this.visibleDist;
}
return(1.0 - (dist.CumulativeDistribution(T) - dist.CumulativeDistribution(0)) / (1.0 - dist.CumulativeDistribution(0)));
}
/// <summary>
/// Updates the Kelly Criterion values
/// </summary>
public void UpdateScores()
{
try
{
// need at least 2 samples
if (_requiresRecalculation && _insightValues.Count > 1)
{
_requiresRecalculation = false;
var averagePowered = Math.Pow(_average, 2);
var variance = _insightValues.Variance();
var denominator = averagePowered + variance;
var kellyCriterionEstimate = denominator.IsNaNOrZero() ? 0 : _average / denominator;
KellyCriterionEstimate = kellyCriterionEstimate.SafeDecimalCast();
var variancePowered = Math.Pow(variance, 2);
var kellyCriterionStandardDeviation = Math.Sqrt(
(1 / variance + 2 * averagePowered / variancePowered)
/ _insightValues.Count - 1);
KellyCriterionProbabilityValue = kellyCriterionStandardDeviation.IsNaNOrZero() ? 1 :
1 - _normalDistribution.CumulativeDistribution(kellyCriterionEstimate / kellyCriterionStandardDeviation)
.SafeDecimalCast();
}
}
catch (Exception exception)
{
// just in case...
Log.Error(exception);
}
}
public static double CF_Modified_Kirk(double S1_0, double S2_0,
double K, double rho, double T, double r,
double sigma1, double sigma2)
{
//Here we calculate our volatility
double a_kirk = Math.Sqrt(Math.Pow(sigma1, 2) - 2 * rho * sigma1 * sigma2 * (S2_0 / (S2_0 + K)) + Math.Pow(sigma2 * (S2_0 / (S2_0 + K)), 2));
double X_t = Math.Log(S1_0);
double x_aster = Math.Log(S2_0 + K);
double I_t = Math.Sqrt(Math.Pow(a_kirk, 2)) + 0.5 * (Math.Pow((sigma2 * S2_0 / (S2_0 + K)) - rho * sigma1, 2)) * (1 / (Math.Pow(Math.Sqrt(Math.Pow(a_kirk, 2)), 3))) * Math.Pow(sigma2, 2) * ((S2_0 * K) / (Math.Pow(S2_0 + K, 2))) * (X_t - x_aster);
//Here we calculate our d1 and d2
double S = S1_0 / (S2_0 + K);
double d1 = (Math.Log(S) + 0.5 * Math.Pow(I_t, 2) * T) / (I_t * Math.Sqrt(T));
double d2 = d1 - I_t * Math.Sqrt(T);
//Fit a normal distribution
var normal = new Normal(0, 1);
//#Here we use the above calculations to approximate the call spread using Kirk's formula
double C_modified_kirk = S1_0 * normal.CumulativeDistribution(d1) - (S2_0 + K) * normal.CumulativeDistribution(d2);
C_modified_kirk *= Math.Exp(-r * T);
return(C_modified_kirk);
}
protected override double Transform(double value)
{
var result = normal.CumulativeDistribution(value);
result = result * difference + lower;
return(result);
}
/// <summary> Takes two normal distributions and returns the probability that a point sample from of the first will be greater than one from the second. That is, the probability of discarding A because of B. </summary>
/// <param name="A">A normal distribution</param>
/// <param name="B">Another normal distribution</param>
/// <returns>P(A>B)</returns>
public static double PairwiseExact(Normal A, Normal B)
{
Normal BMinusA = new Normal(mean: B.Mean - A.Mean,
stddev: Math.Sqrt(A.Variance + B.Variance));
return(BMinusA.CumulativeDistribution(0));
}
protected override double Transform(double value)
{
var result = normal.CumulativeDistribution(value);
result = distribution.InverseCumulativeDistribution(result);
return(result);
}
public static double BSPricing(double s, double k, double t, double r, double sigma, OptionTypeEnum optionType)
{
double[] dValueArray = GetDValues(s, k, t, r, sigma, optionType);
double d1 = dValueArray[0];
double d2 = dValueArray[1];
Normal normal = new Normal();
if (optionType == OptionTypeEnum.Call)
{
return(s * normal.CumulativeDistribution(d1) - k * Math.Exp(-r * t) * normal.CumulativeDistribution(d2));
}
else
{
return(k * Math.Exp(-r * t) * normal.CumulativeDistribution(-d2) - s * normal.CumulativeDistribution(-d1));
}
}
public double pWartosc(double value)
{
Normal norm = new Normal();
double next = norm.CumulativeDistribution(value);
// Console.WriteLine("dystriusa: " + next);
return(next);
}
// Implied Volatility
private static double GetVega(double s, double k, double t, double r, double sigma)
{
Normal normal = new Normal();
double d1 = (Math.Log(s / k) + r * t) / (sigma * t) + 0.5 * sigma * t;
double vega = s * Math.Sqrt(t) * normal.CumulativeDistribution(d1);
return(vega);
}
/// <summary>
/// The Black formula
/// </summary>
/// <param name="putOrCall">put or call.</param>
/// <param name="strike">The strike.</param>
/// <param name="T">The time to maturity in years from the value date to the exercise date.</param>
/// <param name="forward">The forward at the option exercise date.</param>
/// <param name="vol">The lognormal volatility of the underlying price.</param>
/// <param name="discountFactor">The discount factor from the value date to the settlement date of the option.</param>
/// <returns></returns>
public static double Black(PutOrCall putOrCall, double strike, double T, double forward, double vol, double discountFactor)
{
var dist = new Normal();
var sigmaSqrtT = vol * Math.Sqrt(T);
var d1 = 1 / sigmaSqrtT * (Math.Log(forward / strike) + 0.5 * vol * vol);
var d2 = d1 - sigmaSqrtT;
return(discountFactor * (forward * dist.CumulativeDistribution(d1) - strike * dist.CumulativeDistribution(d2)));
}
public static double ApplyAdjustment(double baseWinrate, double adjustment)
{
if (adjustment == 0)
{
return(baseWinrate);
}
return(_standardNormal.CumulativeDistribution(_standardNormal.InverseCumulativeDistribution(baseWinrate) + adjustment));
}
public void hipothesisTesting()
{
Console.WriteLine("*****************Testowanie Hipotez*****************");
double z;
double alpha;
double p;
int FirstClass;
int SecondClass;
Console.WriteLine("Podaj poziom istotności alpha: ");
alpha = Convert.ToDouble(Console.ReadLine(), CultureInfo.InvariantCulture);
anotherHipothesis:
if (DataForHipothesisTesting.Count == 2)
{
Console.WriteLine("Sprawdzany czy da się przypisać daną wartość do właściwej etykiety z prawdopodobieństwem większym niż alpha. \n" +
"Będziemy prowadzić obliczenia dla Etykiety: " + DataForHipothesisTesting[0].Label + " i kolumny: " + DataForHipothesisTesting[0].Collumn + "\n" +
" oraz dla Etykiety: " + DataForHipothesisTesting[1].Label + " i kolumny: " + DataForHipothesisTesting[1].Collumn + ".");
FirstClass = 0;
SecondClass = 1;
}
else
{
Console.WriteLine("Poniżej wybierz numery etykiet, dla których chcesz sprawdzić czy da się przypisać daną wartość do właściwej etykiety z prawdopodobieństwem większym niż alpha.");
for (int i = 0; i < DataForHipothesisTesting.Count; ++i)
{
Console.WriteLine(i + " etykieta: " + DataForHipothesisTesting[i].Label + " kolumna: " + (DataForHipothesisTesting[i].Collumn + 1));
}
Console.WriteLine("Podaj numer pierwszej z etykiet: ");
FirstClass = Int32.Parse(Console.ReadLine());
Console.WriteLine("Podaj numer drugiej z etykiet: ");
SecondClass = Int32.Parse(Console.ReadLine());
}
z = (DataForHipothesisTesting[FirstClass].AritmeticMean - DataForHipothesisTesting[SecondClass].AritmeticMean) / (Math.Pow((Math.Pow(DataForHipothesisTesting[FirstClass].StandardDeviation, 2) / DataForHipothesisTesting[FirstClass].ProbeStrenght) + (Math.Pow(DataForHipothesisTesting[SecondClass].StandardDeviation, 2) / DataForHipothesisTesting[SecondClass].ProbeStrenght), 0.5));
Normal Norm = new Normal();
p = Math.Round(2 * Norm.CumulativeDistribution(-Math.Abs(z)), 6);
Console.WriteLine("alpha: " + alpha);
Console.WriteLine("z: " + z);
Console.WriteLine("p: " + p);
if (p < alpha)
{
Console.WriteLine("Da się przypisać daną do etykiety po wartości tej danej z prawdopodobieństwem " + p);
}
else
{
Console.WriteLine("Nie da się przypisać danej do etykiety po wartości tej danej z prawdopodobieństwem " + p + " mniejszym od alpha.");
}
Console.WriteLine("Czy chcesz przetestować inny zbiór danych? T/N");
string Check = Console.ReadLine();
if (Check == "T" || Check == "t")
{
goto anotherHipothesis;
}
}
/// <summary>
/// Delta = first derivative of price with respect to underlying price.
/// </summary>
/// <returns>delta of the option</returns>
public static double BlackScholesDelta(this EuropeanOption option, Date valueDate, double spot, double vol, double rate, double div)
{
var T = (double)(option._exerciseDate - valueDate) / 365;
double d1 = D1(spot, option._strike, vol, rate, div, T);
double delta;
double dtq = Math.Exp(-div * T);
var dist = new Normal();
if (option._putOrCall == PutOrCall.Call)
{
delta = dtq * dist.CumulativeDistribution(d1);
}
else
{
delta = dtq * (dist.CumulativeDistribution(d1) - 1);
}
return(delta);
}
private static double Nu(double x, double tol)
{
double nu;
double lnu0, lnu1, dk, xk;
int i, k;
// fpnorm(x): pnorm(x, 0, 1, lower.tail=TRUE, log.p=FALSE)
// calculates P(X <= x)
var norm = new Normal(); // N(0, 1)
if (x > 0.01)
{
lnu1 = Math.Log(2.0) - 2 * Math.Log(x);
lnu0 = lnu1;
k = 2;
dk = 0;
for (i = 0; i < k; i++)
{
dk = dk + 1;
xk = -x *Math.Sqrt(dk) / 2.0;
lnu1 = lnu1 - 2.0 * norm.CumulativeDistribution(xk) / dk;
}
while (Math.Abs((lnu1 - lnu0) / lnu1) > tol)
{
lnu0 = lnu1;
for (i = 0; i < k; i++)
{
dk = dk + 1;
xk = -x *Math.Sqrt(dk) / 2.0;
lnu1 = lnu1 - 2.0 * norm.CumulativeDistribution(xk) / dk;
}
k *= 2;
}
}
else
{
lnu1 = -0.583 * x;
}
nu = Math.Exp(lnu1);
return(nu);
}
// Geometric Asian Options
private static double getGeoAsianOptionPrice(double s, double k, double r, double t, double sigma, int n, OptionTypeEnum optionType)
{
double sigsqT = Math.Pow(sigma, 2) * t * (n + 1) * (2 * n + 1) / (6 * n * n);
double muT = 0.5 * sigsqT + (r - 0.5 * sigma * sigma) * t * (n + 1) / (2 * n);
double d1 = (Math.Log(s / k) + (muT + 0.5 * sigsqT)) / (Math.Sqrt(sigsqT));
double d2 = d1 - Math.Sqrt(sigsqT);
Normal normal = new Normal();
if (optionType == OptionTypeEnum.Call)
{
return(Math.Exp(-r * t) * (s * Math.Exp(muT) * normal.CumulativeDistribution(d1) - k * normal.CumulativeDistribution(d2)));
}
else
{
return(Math.Exp(-r * t) * (k * normal.CumulativeDistribution(-d2) - s * Math.Exp(muT) * normal.CumulativeDistribution(-d1)));
}
}
/// <summary>
/// Samples from a truncated normal distribution.
/// </summary>
/// <param name="mean">The distribution's mean.</param>
/// <param name="standardDeviation">The distribution's standard deviation.</param>
/// <param name="minimum">Minimum value.</param>
/// <param name="maximum">Maximum value.</param>
/// <returns>The generated sample.</returns>
public double SampleFromTruncatedNormal(
double mean,
double standardDeviation,
double minimum,
double maximum)
{
// Create the underlying normal distribution to make use of inversion technique.
var originalDistribution = new Normal(mean, standardDeviation);
// Select a random value of the distribution function whose inverse is part of the interval.
var randomFactor = this.SampleFromUniformDistribution(0, 1);
var distributionValueWidth = originalDistribution.CumulativeDistribution(maximum)
- originalDistribution.CumulativeDistribution(minimum);
var randomDistributionValueInInterval = originalDistribution.CumulativeDistribution(minimum)
+ (randomFactor * distributionValueWidth);
// Return that inverse.
return(originalDistribution.InverseCumulativeDistribution(randomDistributionValueInInterval));
}
/// <summary>
/// The Black the scholes formula
/// </summary>
/// <param name="putOrCall">put or call.</param>
/// <param name="strike">The strike.</param>
/// <param name="T">The time to maturity in years.</param>
/// <param name="spot">The underlying spot price.</param>
/// <param name="vol">The lognormal volatility of the underlying price.</param>
/// <param name="rate">The continuous rate used for drifting the underlying and discounting the payoff.</param>
/// <param name="div">The continuous dividend yield that decreased the drift on the underlying.</param>
/// <returns></returns>
public static double BlackScholes(PutOrCall putOrCall, double strike, double T, double spot, double vol, double rate,
double div)
{
var dist = new Normal();
var sigmaSqrtT = vol * Math.Sqrt(T);
var d1 = 1 / sigmaSqrtT * (Math.Log(spot / strike) + rate - div + 0.5 * vol * vol);
var d2 = d1 - sigmaSqrtT;
var forward = spot * Math.Exp((rate - div) * T);
return(Math.Exp(-rate * T) * (forward * dist.CumulativeDistribution(d1) - strike * dist.CumulativeDistribution(d2)));
}
private double Transform(double value)
{
var result = transformationCache.Get(value);
if (result == 0)
{
result = standardNormal.CumulativeDistribution(value);
result = distribution.InverseCumulativeDistribution(result);
transformationCache.Add(value, result);
}
return(result);
}
/// <summary>
/// Rho = first derivative of price with respect to the risk-free rate.
/// </summary>
/// <returns>rho of the option</returns>
public static double BlackScholesRho(this EuropeanOption option, Date valueDate, double spot, double vol, double rate, double div)
{
var dist = new Normal();
var T = (double)(option._exerciseDate - valueDate) / 365;
double d2 = D2(spot, option._strike, vol, rate, div, T);
double rho;
var flag = (double)option._putOrCall;
rho = flag * T * option._strike * Math.Exp(-rate * T) * dist.CumulativeDistribution(flag * d2);
return(rho);
}
public static double CF_Kirk(double S1_0, double S2_0,
double K, double rho, double T, double r,
double sigma1, double sigma2)
{
//Here we calculate our volatility
double a_kirk = Math.Sqrt(Math.Pow(sigma1, 2) - 2 * rho * sigma1 * sigma2 * (S2_0 / (S2_0 + K)) + Math.Pow(sigma2 * (S2_0 / (S2_0 + K)), 2));
//Here we calculate our d1 and d2
double S = (S1_0 / (S2_0 + K));
double d1 = (Math.Log(S) + 0.5 * Math.Pow(a_kirk, 2) * T) / (a_kirk * Math.Sqrt(T));
double d2 = d1 - a_kirk * Math.Sqrt(T);
//Fit a normal distribution
var normal = new Normal(0, 1);
//#Here we use the above calculations to approximate the call spread using Kirk's formula
double C_kirk = S1_0 * normal.CumulativeDistribution(d1) - (S2_0 + K) * normal.CumulativeDistribution(d2);
C_kirk *= Math.Exp(-r * T);
return(C_kirk);
}
static void Main(string[] args)
{
IRIS iris = new IRIS(@"~\..\..\..\data\input\iris.data.csv");
iris.start(iris.Dane);
Normal norm = new Normal();
double next = norm.CumulativeDistribution(1 - 1.96);
// Console.WriteLine("dystriusa: " + next);
Console.ReadKey();
}
public void ValidateSkewedNormalDistribution(double location, double scale, double skew, double x)
{
var sn = new SkewedGeneralizedT(location, scale, skew, 2, double.PositiveInfinity);
var n = new Normal(location, scale);
var sp = sn.CumulativeDistribution(x);
var p = n.CumulativeDistribution(x);
if (skew > 0)
{
Assert.IsTrue(sp > p);
}
else
{
Assert.IsTrue(sp < p);
}
}
public static void CalculatePValue(List <LSPADItem> items)
{
items.Sort((m1, m2) => m1.Intensity.CompareTo(m2.Intensity));
var oneSix = items.Count / 6;
List <double> ratios = new List <double>();
for (int i = 0; i < oneSix; i++)
{
ratios.Add(items[i].LogRatio);
}
int lastOne = 0;
int firstOne = oneSix - 1;
for (int i = 0; i < items.Count; i++)
{
int first = Math.Min(i + oneSix, items.Count);
int last = Math.Max(i - oneSix, 1);
for (int a = lastOne; a < last; a++)
{
ratios.RemoveAt(0);
}
for (int a = firstOne; a < first; a++)
{
ratios.Add(items[a].LogRatio);
}
var acc = new MeanStandardDeviation(ratios);
items[i].Mean = acc.Mean;
items[i].SD = acc.StdDev;
Normal nd = new Normal(acc.Mean, acc.StdDev);
items[i].PValue = nd.CumulativeDistribution(items[i].LogRatio);
items[i].PValue = Math.Min(items[i].PValue, 1 - items[i].PValue);
}
}
/// <summary>
/// Run example
/// </summary>
/// <a href="http://en.wikipedia.org/wiki/Normal_distribution">Normal distribution</a>
public void Run()
{
// 1. Initialize the new instance of the Normal distribution class with parameters Mean = 0, StdDev = 1
var normal = new Normal(0, 1);
Console.WriteLine(@"1. Initialize the new instance of the Normal distribution class with parameters Mean = {0}, StdDev = {1}", normal.Mean, normal.StdDev);
Console.WriteLine();
// 2. Distributuion properties:
Console.WriteLine(@"2. {0} distributuion properties:", normal);
// Cumulative distribution function
Console.WriteLine(@"{0} - Сumulative distribution at location '0.3'", normal.CumulativeDistribution(0.3).ToString(" #0.00000;-#0.00000"));
// Probability density
Console.WriteLine(@"{0} - Probability density at location '0.3'", normal.Density(0.3).ToString(" #0.00000;-#0.00000"));
// Log probability density
Console.WriteLine(@"{0} - Log probability density at location '0.3'", normal.DensityLn(0.3).ToString(" #0.00000;-#0.00000"));
// Entropy
Console.WriteLine(@"{0} - Entropy", normal.Entropy.ToString(" #0.00000;-#0.00000"));
// Largest element in the domain
Console.WriteLine(@"{0} - Largest element in the domain", normal.Maximum.ToString(" #0.00000;-#0.00000"));
// Smallest element in the domain
Console.WriteLine(@"{0} - Smallest element in the domain", normal.Minimum.ToString(" #0.00000;-#0.00000"));
// Mean
Console.WriteLine(@"{0} - Mean", normal.Mean.ToString(" #0.00000;-#0.00000"));
// Median
Console.WriteLine(@"{0} - Median", normal.Median.ToString(" #0.00000;-#0.00000"));
// Mode
Console.WriteLine(@"{0} - Mode", normal.Mode.ToString(" #0.00000;-#0.00000"));
// Variance
Console.WriteLine(@"{0} - Variance", normal.Variance.ToString(" #0.00000;-#0.00000"));
// Standard deviation
Console.WriteLine(@"{0} - Standard deviation", normal.StdDev.ToString(" #0.00000;-#0.00000"));
// Skewness
Console.WriteLine(@"{0} - Skewness", normal.Skewness.ToString(" #0.00000;-#0.00000"));
Console.WriteLine();
// 3. Generate 10 samples
Console.WriteLine(@"3. Generate 10 samples");
for (var i = 0; i < 10; i++)
{
Console.Write(normal.Sample().ToString("N05") + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 4. Generate 100000 samples of the Normal(0, 1) distribution and display histogram
Console.WriteLine(@"4. Generate 100000 samples of the Normal(0, 1) distribution and display histogram");
var data = new double[100000];
for (var i = 0; i < data.Length; i++)
{
data[i] = normal.Sample();
}
ConsoleHelper.DisplayHistogram(data);
Console.WriteLine();
// 5. Generate 100000 samples of the Normal(-10, 0.2) distribution and display histogram
Console.WriteLine(@"5. Generate 100000 samples of the Normal(-10, 0.01) distribution and display histogram");
normal.Mean = -10;
normal.StdDev = 0.01;
for (var i = 0; i < data.Length; i++)
{
data[i] = normal.Sample();
}
ConsoleHelper.DisplayHistogram(data);
}
private static double NormalDistr(double x)
{
return(_normalDistribution.CumulativeDistribution(x));
}