public void ProbabilityFunctionTest()
{
var p1 = new NormalDistribution(4.2, 1);
var p2 = new NormalDistribution(7.0, 2);
Independent<NormalDistribution> target = new Independent<NormalDistribution>(p1, p2);
double[] x;
double actual, expected;
x = new double[] { 4.2, 7.0 };
actual = target.ProbabilityDensityFunction(x);
expected = p1.ProbabilityDensityFunction(x[0]) * p2.ProbabilityDensityFunction(x[1]);
Assert.AreEqual(expected, actual, 1e-10);
Assert.IsFalse(double.IsNaN(actual));
x = new double[] { 0.0, 0.0 };
actual = target.ProbabilityDensityFunction(x);
expected = p1.ProbabilityDensityFunction(x[0]) * p2.ProbabilityDensityFunction(x[1]);
Assert.AreEqual(expected, actual, 1e-10);
Assert.IsFalse(double.IsNaN(actual));
x = new double[] { 7.0, 4.2 };
actual = target.ProbabilityDensityFunction(x);
expected = p1.ProbabilityDensityFunction(x[0]) * p2.ProbabilityDensityFunction(x[1]);
Assert.AreEqual(expected, actual, 1e-10);
Assert.IsFalse(double.IsNaN(actual));
}
public void ConstructorTest5()
{
var normal = new NormalDistribution(mean: 4, stdDev: 4.2);
double mean = normal.Mean; // 4.0
double median = normal.Median; // 4.0
double var = normal.Variance; // 17.64
double cdf = normal.DistributionFunction(x: 1.4); // 0.26794249453351904
double pdf = normal.ProbabilityDensityFunction(x: 1.4); // 0.078423391448155175
double lpdf = normal.LogProbabilityDensityFunction(x: 1.4); // -2.5456330358182586
double ccdf = normal.ComplementaryDistributionFunction(x: 1.4); // 0.732057505466481
double icdf = normal.InverseDistributionFunction(p: cdf); // 1.4
double hf = normal.HazardFunction(x: 1.4); // 0.10712736480747137
double chf = normal.CumulativeHazardFunction(x: 1.4); // 0.31189620872601354
string str = normal.ToString(CultureInfo.InvariantCulture); // N(x; μ = 4, σ² = 17.64)
Assert.AreEqual(4.0, mean);
Assert.AreEqual(4.0, median);
Assert.AreEqual(17.64, var);
Assert.AreEqual(0.31189620872601354, chf);
Assert.AreEqual(0.26794249453351904, cdf);
Assert.AreEqual(0.078423391448155175, pdf);
Assert.AreEqual(-2.5456330358182586, lpdf);
Assert.AreEqual(0.10712736480747137, hf);
Assert.AreEqual(0.732057505466481, ccdf);
Assert.AreEqual(1.4, icdf);
Assert.AreEqual("N(x; μ = 4, σ² = 17.64)", str);
}
public PinkNoise(IRandomGenerator randomGenerator, float rmsAmplitude)
{
if (null == randomGenerator)
throw new ArgumentNullException("randomGenerator");
_whiteGenerator = new NormalDistribution(randomGenerator, 0, RmsScale * rmsAmplitude);
}
public void ConstructorTest()
{
var p1 = new NormalDistribution(4.2, 1);
var p2 = new NormalDistribution(7.0, 2);
Independent<NormalDistribution> target = new Independent<NormalDistribution>(p1, p2);
Assert.AreEqual(target.Components[0], p1);
Assert.AreEqual(target.Components[1], p2);
Assert.AreEqual(2, target.Dimension);
Assert.AreEqual(4.2, target.Mean[0]);
Assert.AreEqual(7.0, target.Mean[1]);
Assert.AreEqual(1, target.Variance[0]);
Assert.AreEqual(4, target.Variance[1]);
Assert.AreEqual(1, target.Covariance[0, 0]);
Assert.AreEqual(4, target.Covariance[1, 1]);
Assert.AreEqual(0, target.Covariance[0, 1]);
Assert.AreEqual(0, target.Covariance[1, 0]);
var text = target.ToString("N2", System.Globalization.CultureInfo.InvariantCulture);
Assert.AreEqual("Independent(x0, x1; N(x0; μ = 4.20, σ² = 1.00) + N(x1; μ = 7.00, σ² = 4.00))", text);
}
public void ConstructorTest2()
{
var original = new NormalDistribution(mean: 4, stdDev: 4.2);
var normal = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
testNormal(normal);
}
public static HiddenMarkovClassifier<Independent> CreateModel1()
{
// Create a Continuous density Hidden Markov Model Sequence Classifier
// to detect a multivariate sequence and the same sequence backwards.
double[][][] sequences = new double[][][]
{
new double[][]
{
// This is the first sequence with label = 0
new double[] { 0 },
new double[] { 1 },
new double[] { 2 },
new double[] { 3 },
new double[] { 4 },
},
new double[][]
{
// This is the second sequence with label = 1
new double[] { 4 },
new double[] { 3 },
new double[] { 2 },
new double[] { 1 },
new double[] { 0 },
}
};
// Labels for the sequences
int[] labels = { 0, 1 };
// Creates a sequence classifier containing 2 hidden Markov Models
// with 2 states and an underlying Normal distribution as density.
NormalDistribution component = new NormalDistribution();
Independent density = new Independent(component);
var classifier = new HiddenMarkovClassifier<Independent>(2, new Ergodic(2), density);
// Configure the learning algorithms to train the sequence classifier
var teacher = new HiddenMarkovClassifierLearning<Independent>(classifier,
// Train each model until the log-likelihood changes less than 0.001
modelIndex => new BaumWelchLearning<Independent>(classifier.Models[modelIndex])
{
Tolerance = 0.0001,
Iterations = 0
}
);
// Train the sequence classifier using the algorithm
double logLikelihood = teacher.Run(sequences, labels);
Assert.AreEqual(-13.271981026832929d, logLikelihood);
return classifier;
}
public void LearnTest1()
{
// Create a Continuous density Hidden Markov Model Sequence Classifier
// to detect a univariate sequence and the same sequence backwards.
double[][] sequences = new double[][]
{
new double[] { 0,1,2,3,4 }, // This is the first sequence with label = 0
new double[] { 4,3,2,1,0 }, // This is the second sequence with label = 1
};
// Labels for the sequences
int[] labels = { 0, 1 };
// Creates a sequence classifier containing 2 hidden Markov Models
// with 2 states and an underlying Normal distribution as density.
NormalDistribution density = new NormalDistribution();
var classifier = new HiddenMarkovClassifier<NormalDistribution>(2, new Ergodic(2), density);
// Configure the learning algorithms to train the sequence classifier
var teacher = new HiddenMarkovClassifierLearning<NormalDistribution>(classifier,
// Train each model until the log-likelihood changes less than 0.001
modelIndex => new BaumWelchLearning<NormalDistribution>(classifier.Models[modelIndex])
{
Tolerance = 0.0001,
Iterations = 0
}
);
// Train the sequence classifier using the algorithm
double logLikelihood = teacher.Run(sequences, labels);
// Calculate the probability that the given
// sequences originated from the model
double likelihood1, likelihood2;
// Try to classify the first sequence (output should be 0)
int c1 = classifier.Compute(sequences[0], out likelihood1);
// Try to classify the second sequence (output should be 1)
int c2 = classifier.Compute(sequences[1], out likelihood2);
Assert.AreEqual(0, c1);
Assert.AreEqual(1, c2);
Assert.AreEqual(-13.271981026832929, logLikelihood, 1e-10);
Assert.AreEqual(0.99999791320102149, likelihood1, 1e-10);
Assert.AreEqual(0.99999791320102149, likelihood2, 1e-10);
Assert.IsFalse(double.IsNaN(logLikelihood));
Assert.IsFalse(double.IsNaN(likelihood1));
Assert.IsFalse(double.IsNaN(likelihood2));
}
public void ConstructorTest5()
{
var normal = new NormalDistribution(mean: 4, stdDev: 4.2);
double mean = normal.Mean; // 4.0
double median = normal.Median; // 4.0
double mode = normal.Mode; // 4.0
double var = normal.Variance; // 17.64
double cdf = normal.DistributionFunction(x: 1.4); // 0.26794249453351904
double pdf = normal.ProbabilityDensityFunction(x: 1.4); // 0.078423391448155175
double lpdf = normal.LogProbabilityDensityFunction(x: 1.4); // -2.5456330358182586
double ccdf = normal.ComplementaryDistributionFunction(x: 1.4); // 0.732057505466481
double icdf = normal.InverseDistributionFunction(p: cdf); // 1.4
double hf = normal.HazardFunction(x: 1.4); // 0.10712736480747137
double chf = normal.CumulativeHazardFunction(x: 1.4); // 0.31189620872601354
string str = normal.ToString(CultureInfo.InvariantCulture); // N(x; μ = 4, σ² = 17.64)
Assert.AreEqual(4.0, mean);
Assert.AreEqual(4.0, median);
Assert.AreEqual(4.0, mode);
Assert.AreEqual(17.64, var);
Assert.AreEqual(0.31189620872601354, chf);
Assert.AreEqual(0.26794249453351904, cdf);
Assert.AreEqual(0.078423391448155175, pdf);
Assert.AreEqual(-2.5456330358182586, lpdf);
Assert.AreEqual(0.10712736480747137, hf);
Assert.AreEqual(0.732057505466481, ccdf);
Assert.AreEqual(1.4, icdf);
Assert.AreEqual("N(x; μ = 4, σ² = 17.64)", str);
Assert.AreEqual(Accord.Math.Normal.Function(normal.ZScore(4.2)), normal.DistributionFunction(4.2));
Assert.AreEqual(Accord.Math.Normal.Derivative(normal.ZScore(4.2)) / normal.StandardDeviation, normal.ProbabilityDensityFunction(4.2), 1e-16);
Assert.AreEqual(Accord.Math.Normal.LogDerivative(normal.ZScore(4.2)) - Math.Log(normal.StandardDeviation), normal.LogProbabilityDensityFunction(4.2), 1e-15);
var range1 = normal.GetRange(0.95);
var range2 = normal.GetRange(0.99);
var range3 = normal.GetRange(0.01);
Assert.AreEqual(-2.9083852331961833, range1.Min);
Assert.AreEqual(10.908385233196183, range1.Max);
Assert.AreEqual(-5.7706610709715314, range2.Min);
Assert.AreEqual(13.770661070971531, range2.Max);
Assert.AreEqual(-5.7706610709715314, range3.Min);
Assert.AreEqual(13.770661070971531, range3.Max);
}
public void NormalGenerateTest()
{
// Create a Normal with mean 2 and sigma 5
var normal = new NormalDistribution(2, 5);
// Generate 1000000 samples from it
double[] samples = normal.Generate(1000000);
// Try to estimate a new Normal distribution from the
// generated samples to check if they indeed match
var actual = NormalDistribution.Estimate(samples);
string result = actual.ToString("N2"); // N(x; μ = 2.01, σ² = 25.03)
Assert.AreEqual("N(x; μ = 2.01, σ² = 25.03)", result);
}
public static NormalDistribution ByParams(double expectation, double variance)
{
if (Double.IsInfinity(expectation) || Double.IsNaN(expectation))
throw new ArgumentException("The expectation must be a finite number");
if (variance <= 0 || Double.IsInfinity(expectation) || Double.IsNaN(expectation))
throw new ArgumentException("The variance must be a positive finite number");
NormalDistribution distribution = new NormalDistribution();
distribution.Expectation = expectation;
distribution.Variance = variance;
distribution.ComputeInternalParameters();
return distribution;
}
// Use this for initialization
void Start()
{
// Save a pointer to the fusion engine
fusionEngine = GetComponentInParent<FusionEngine>();
// Get a pointer to the target
targets = GameObject.FindGameObjectsWithTag("Target");
// Noise distribution
nd = new NormalDistribution(0, 1);
noiseCovariance = new Matrix(3, 3);
noiseCovariance[0, 0] = 1e-3;
noiseCovariance[1, 1] = 1e-3;
noiseCovariance[2, 2] = 1e-3;
noiseCovCholT = noiseCovariance.CholeskyDecomposition.TriangularFactor.Clone();
noiseCovCholT.Transpose();
// Reset time since the last update
timeSinceLastUpdateSec = 0.0f;
}
public void ConstructorTest1()
{
NormalDistribution normal = new NormalDistribution(4.2, 1.2);
MultivariateNormalDistribution target = new MultivariateNormalDistribution(new[] { 4.2 }, new[,] { { 1.2 * 1.2 } });
double[] mean = target.Mean;
double[] median = target.Median;
double[] var = target.Variance;
double[,] cov = target.Covariance;
double apdf1 = target.ProbabilityDensityFunction(new double[] { 2 });
double apdf2 = target.ProbabilityDensityFunction(new double[] { 4 });
double apdf3 = target.ProbabilityDensityFunction(new double[] { 3 });
double alpdf = target.LogProbabilityDensityFunction(new double[] { 3 });
double acdf = target.DistributionFunction(new double[] { 3 });
double accdf = target.ComplementaryDistributionFunction(new double[] { 3 });
double epdf1 = target.ProbabilityDensityFunction(new double[] { 2 });
double epdf2 = target.ProbabilityDensityFunction(new double[] { 4 });
double epdf3 = target.ProbabilityDensityFunction(new double[] { 3 });
double elpdf = target.LogProbabilityDensityFunction(new double[] { 3 });
double ecdf = target.DistributionFunction(new double[] { 3 });
double eccdf = target.ComplementaryDistributionFunction(new double[] { 3 });
Assert.AreEqual(normal.Mean, target.Mean[0]);
Assert.AreEqual(normal.Median, target.Median[0]);
Assert.AreEqual(normal.Variance, target.Variance[0]);
Assert.AreEqual(normal.Variance, target.Covariance[0, 0]);
Assert.AreEqual(epdf1, apdf1);
Assert.AreEqual(epdf2, apdf2);
Assert.AreEqual(epdf3, apdf3);
Assert.AreEqual(elpdf, alpdf);
Assert.AreEqual(ecdf, acdf);
Assert.AreEqual(eccdf, accdf);
Assert.AreEqual(1.0 - ecdf, eccdf);
}
public Combat(Unit attacker, Unit defender, bool useRandomisedCombatEfficiency, List<Unit> antiAirUnits = null)
{
UseRandomisedCombatEfficiency = useRandomisedCombatEfficiency;
Generator = new NormalDistribution(GameConstants.CombatEfficiencyMean, GameConstants.CombatEfficiencyDeviation);
Attacker = new UnitCombatState(attacker, this);
Defender = new UnitCombatState(defender, this);
if (attacker.IsAirUnit())
{
AttackType = AttackType.AirAttack;
AntiAirUnits = antiAirUnits.Select((Unit x) => new UnitCombatState(x, this)).ToList();
foreach (var unit in AntiAirUnits)
unit.SetDamage(unit.Unit.Type.Stats.AirAttack.Value);
}
else if (attacker.IsArtillery())
AttackType = AttackType.ArtilleryAttack;
else
AttackType = AttackType.GroundAttack;
// Calculate the outcome right away
Attack();
}
public void ConstructorTest()
{
var p1 = new NormalDistribution(4.2, 1);
var p2 = new NormalDistribution(7.0, 2);
Independent<NormalDistribution> target = new Independent<NormalDistribution>(p1, p2);
Assert.AreEqual(target.Components[0], p1);
Assert.AreEqual(target.Components[1], p2);
Assert.AreEqual(2, target.Dimension);
Assert.AreEqual(4.2, target.Mean[0]);
Assert.AreEqual(7.0, target.Mean[1]);
Assert.AreEqual(1, target.Variance[0]);
Assert.AreEqual(4, target.Variance[1]);
Assert.AreEqual(1, target.Covariance[0, 0]);
Assert.AreEqual(4, target.Covariance[1, 1]);
Assert.AreEqual(0, target.Covariance[0, 1]);
Assert.AreEqual(0, target.Covariance[1, 0]);
}
public void MixtureFitTest()
{
var samples1 = new NormalDistribution(mean: -2, stdDev: 0.5).Generate(100000);
var samples2 = new NormalDistribution(mean: +4, stdDev: 0.5).Generate(100000);
// Mix the samples from both distributions
var samples = samples1.Concatenate(samples2);
// Create a new mixture distribution with two Normal components
var mixture = new Mixture <NormalDistribution>(new[] { 0.2, 0.8 },
new NormalDistribution(-1),
new NormalDistribution(+1));
// Estimate the distribution
mixture.Fit(samples, new MixtureOptions
{
Iterations = 50,
Threshold = 0
});
var result = mixture.ToString("N2", System.Globalization.CultureInfo.InvariantCulture);
Assert.AreEqual("Mixture(x; 0.50*N(x; μ = -2.00, σ² = 0.25) + 0.50*N(x; μ = 4.00, σ² = 0.25))", result);
}
public void GammaEffectSizeMultimodalTest()
{
var random = new Random(42);
var x = new NormalDistribution(0, 1).Random(random).Next(200)
.Concat(new NormalDistribution(10, 1).Random(random).Next(200))
.ToSample();
var y = new NormalDistribution(0, 1).Random(random).Next(200)
.Concat(new NormalDistribution(20, 1).Random(random).Next(200))
.ToSample();
var probabilities = new Probability[] { 0.2, 0.3, 0.4, 0.6, 0.7, 0.8 };
var minExpected = new[] { -0.1, -0.1, -0.1, 0.8, 0.8, 0.8 };
var maxExpected = new[] { 0.1, 0.1, 0.1, 0.9, 0.9, 0.9 };
var gammaEffectSizeFunction = GammaEffectSizeFunction.Instance;
for (int i = 0; i < probabilities.Length; i++)
{
var p = probabilities[i];
double gamma = gammaEffectSizeFunction.GetValue(x, y, p);
output.WriteLine($"{p}: {gamma:0.0000}");
Assert.True(minExpected[i] < gamma && gamma < maxExpected[i]);
}
}
public DataTable CreateNormalData(double mean, double std, double?min = null, double?max = null, int numberOfData = 300)
{
var gaussTable = new DataTable();
var normalDistribution = new NormalDistribution(mean, std);
var randomGenerator = new RandomGenerator();
gaussTable.AddColumn <double>(Constants.X);
gaussTable.AddColumn <double>(Constants.Y);
var minToUse = min ?? mean - 4 * std;
var maxToUse = max ?? mean + 4 * std;
for (int i = 0; i < numberOfData; i++)
{
var x = randomGenerator.UniformDeviate(minToUse, maxToUse);
var y = normalDistribution.ProbabilityDensityFor(x);
var row = gaussTable.NewRow();
row[Constants.X] = x;
row[Constants.Y] = y;
gaussTable.Rows.Add(row);
}
return(gaussTable);
}
static public double[,] GenerateData(int smpCount, int n, string exprM, string exprS)
{
double[,] data = new double[smpCount, n];
Parser prsM = new Parser(), prsS = new Parser();
prsM.SetExpr(exprM);
prsS.SetExpr(exprS);
ParserVariable varT = new ParserVariable();
prsM.DefineVar("t", varT);
prsS.DefineVar("t", varT);
NormalDistribution dist = new NormalDistribution();
for (int i = 0; i < smpCount; i++)
{
varT.Value = i + 1;
dist.SetDistributionParameters(prsM.Eval(), prsS.Eval());
for (int j = 0; j < n; j++)
{
data[i, j] = dist.NextDouble();
}
}
return(data);
}
public void FitTest()
{
double expectedMean = 1.125;
double expectedSigma = 1.01775897605147;
NormalDistribution target;
target = new NormalDistribution();
double[] observations = { 0.10, 0.40, 2.00, 2.00 };
double[] weights = { 0.25, 0.25, 0.25, 0.25 };
target.Fit(observations, weights);
Assert.AreEqual(expectedMean, target.Mean);
Assert.AreEqual(expectedSigma, target.StandardDeviation, 1e-6);
target = new NormalDistribution();
double[] observations2 = { 0.10, 0.10, 0.40, 2.00 };
double[] weights2 = { 0.125, 0.125, 0.25, 0.50 };
target.Fit(observations2, weights2);
Assert.AreEqual(expectedMean, target.Mean);
// Assert.AreEqual(expectedSigma, target.StandardDeviation, 1e-6);
}
/// <summary>
/// Creates a new instance of the <see cref="ClosingStructuresInput"/> class.
/// </summary>
public ClosingStructuresInput()
{
factorStormDurationOpenStructure = new RoundedDouble(2, 1.0);
deviationWaveDirection = new RoundedDouble(deviationWaveDirectionNumberOfDecimals);
drainCoefficient = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.2
};
modelFactorSuperCriticalFlow = new NormalDistribution(2)
{
Mean = (RoundedDouble)1.1,
StandardDeviation = (RoundedDouble)0.05
};
thresholdHeightOpenWeir = new NormalDistribution(2);
areaFlowApertures = new LogNormalDistribution(2);
levelCrestStructureNotClosing = new NormalDistribution(2);
insideWaterLevel = new NormalDistribution(2);
SetDefaultSchematizationProperties();
}
public void SetBlackScholesPrice()
{
double d1 = (1 / (AnnualVolatility * Math.Sqrt(ValuationTimeSpan.Years())))
* (Math.Log(StockPrice / Strike) + (RiskFreeRate + 0.5 * Math.Pow(AnnualVolatility, 2)) * ValuationTimeSpan.Years());
double d2 = d1 - AnnualVolatility * Math.Sqrt(ValuationTimeSpan.Years());
NormalDistribution normalDistribution = new NormalDistribution();
if (OptionType == Enums.OptionType.Call)
{
BlackScholesValue = normalDistribution.DistributionFunction(d1) * StockPrice
- normalDistribution.DistributionFunction(d2) * Strike * Math.Exp(-RiskFreeRate * ValuationTimeSpan.Years());
}
else if (OptionType == Enums.OptionType.Put)
{
BlackScholesValue = -normalDistribution.DistributionFunction(-d1) * StockPrice
+ normalDistribution.DistributionFunction(-d2) * Strike * Math.Exp(-RiskFreeRate * ValuationTimeSpan.Years());
}
else
{
throw new Exception($"Failed: OptionType {OptionType.ToString()} is not supported");
}
}
public void Run()
{
var x = new NormalDistribution(mean: 20, stdDev: 2).Random(1).Next(20).Concat(
new NormalDistribution(mean: 40, stdDev: 2).Random(2).Next(20)).ToArray();
var y = new NormalDistribution(mean: 20, stdDev: 2).Random(3).Next(20).Concat(
new NormalDistribution(mean: 80, stdDev: 2).Random(4).Next(20)).ToArray();
var probabilities = new[] { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 };
var shift = ShiftFunction.Instance.Values(x, y, probabilities);
var ratio = RatioFunction.Instance.Values(x, y, probabilities);
Console.WriteLine("Probability Shift Ratio");
for (int i = 0; i < probabilities.Length; i++)
{
Console.WriteLine(
probabilities[i].ToString("N1").PadRight(11) + " " +
shift[i].ToString("N1").PadLeft(5) + " " +
ratio[i].ToString("N1").PadLeft(5));
}
Console.WriteLine();
Console.WriteLine("Shift Range: " + ShiftRangeEstimator.Instance.GetRange(x, y));
Console.WriteLine("Ratio Range: " + RatioRangeEstimator.Instance.GetRange(x, y));
}
public static double CalculateCorrelation(double[] set1, double[] set2, bool regulate = true)
{
var x = NormalDistribution.Estimate(set1, new NormalOptions()
{
Regularization = regulate ? 1 : 0
});
var y = NormalDistribution.Estimate(set2, new NormalOptions()
{
Regularization = regulate ? 1 : 0
});
double totalSum = 0;
for (int i = 0; i < set1.Length; i++)
{
totalSum += (set1[i] - x.Mean) * (set2[i] - y.Mean);
}
totalSum /= (set1.Length - 1);
var corr = totalSum / (x.StandardDeviation * y.StandardDeviation);
return(corr);
}
public void MomentMapTest()
{
Distribution d = new NormalDistribution();
for (int n = 1; n < 11; n++)
{
double[] K = new double[n + 1];
K[0] = 1.0;
if (K.Length > 1)
{
K[1] = 0.0;
}
if (K.Length > 2)
{
K[2] = 1.0;
}
//for (int m = 1; m < K.Length; m++) {
// K[m] = AdvancedIntegerMath.Factorial(m - 1);
//}
double M = MomentMath.RawMomentFromCumulants(K);
Console.WriteLine("{0} {1}", d.Moment(n), M);
}
}
//[TestMethod]
public void TimeNormalGenerators()
{
Random rng = new Random(1);
//IDeviateGenerator nRng = new BoxMullerNormalGenerator();
//IDeviateGenerator nRng = new PolarRejectionNormalDeviateGenerator();
//IDeviateGenerator nRng = new RatioOfUniformsNormalGenerator();
IDeviateGenerator nRng = new LevaNormalGenerator();
//Sample sample = new Sample();
ContinuousDistribution nrm = new NormalDistribution();
Stopwatch timer = Stopwatch.StartNew();
double sum = 0.0;
for (int i = 0; i < 10000000; i++)
{
sum += nrm.InverseLeftProbability(rng.NextDouble());
}
timer.Stop();
//Console.WriteLine(sample.KolmogorovSmirnovTest(new NormalDistribution()).RightProbability);
Console.WriteLine(sum);
Console.WriteLine(timer.ElapsedMilliseconds);
}
/// <summary>
/// Plots the sealing slabs.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public override IEnumerable <T> PlotSealingSlabs <T>()
{
var sealingSlabs = base.PlotSealingSlabs <T>();
var randomDerivationOffset = new NormalDistribution(0, standardDerivationOffset);
var randomDerivationRadius = new NormalDistribution(0, standardDerivationRadius);
var randomDerivationDrillingPoint = new NormalDistribution(0, standardDerivationDrillingPoint);
foreach (var sealingSlab in sealingSlabs)
{
sealingSlab.BaseX = sealingSlab.X;
sealingSlab.BaseY = sealingSlab.Y;
sealingSlab.OffsetX = (int)GetRandomDerivationOffsetPixel(randomDerivationOffset);
sealingSlab.OffsetY = (int)GetRandomDerivationOffsetPixel(randomDerivationOffset);
sealingSlab.OffsetDrillingPointX = (int)GetRandomDerivationDrillingPointPixel(randomDerivationDrillingPoint);
sealingSlab.OffsetDrillingPointY = (int)GetRandomDerivationDrillingPointPixel(randomDerivationDrillingPoint);
sealingSlab.Radius = (int)(sealingSlab.Radius + GetRandomDerivationRadiusPixel(randomDerivationRadius));
}
return(sealingSlabs);
}
public void KolmogorovSmirnovTestConstructorTest2()
{
// Test against a Normal distribution
double[] sample = { 0.621, 0.503, 0.203, 0.477, 0.710, 0.581, 0.329, 0.480, 0.554, 0.382 };
// The sample is most likely from a uniform distribution, so it would
// most likely be different from a standard normal distribution.
NormalDistribution distribution = NormalDistribution.Standard;
var target = new KolmogorovSmirnovTest(sample, distribution);
Assert.AreEqual(distribution, target.TheoreticalDistribution);
Assert.AreEqual(KolmogorovSmirnovTestHypothesis.SampleIsDifferent, target.Hypothesis);
Assert.AreEqual(DistributionTail.TwoTail, target.Tail);
Assert.AreEqual(0.580432, target.Statistic, 1e-5);
Assert.AreEqual(0.000999, target.PValue, 1e-5);
Assert.IsFalse(Double.IsNaN(target.Statistic));
// The null hypothesis can be rejected:
// the sample is not from a standard Normal distribution
Assert.IsTrue(target.Significant);
}
public string SetDistributionForBuilding(string name, int?ageQuant)
{
if (string.IsNullOrEmpty(Name))
{
Name = name;
}
if (DistributionFunction == null && DistributionfunctionString != null)
{
SetDistributionFunctionFromString();
}
if (DistributionFunction != null)
{
CanGenerateSamples = true;
return(string.Empty);
}
if (NumberOfSamples == 0 || StDeviation == 0)
{
CanGenerateSamples = false;
return("Stat with name " + (Name) + " and ageQuant= " + (ageQuant ?? -1) + "is marked as CanGenerateSamples=false due to lacking samples");
}
try
{
DistributionFunction = new NormalDistribution(Mean, StDeviation);
CanGenerateSamples = true;
return("Warning: Found no distribution-function for " + (Name) + " and ageQuant= " + (ageQuant ?? -1) + $". Create one using NormalDistribution using mean={Mean} and stddev={StDeviation}");
}
catch (Exception e)
{
CanGenerateSamples = false;
return("Stat with name " + (Name) + " and ageQuant= " + (ageQuant ?? -1) + " is marked as CanGenerateSamples=false due failure to create NormalDistribution: " + e.Message);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var mockRepository = new MockRepository();
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
var distribution = new NormalDistribution();
var designVariable = new NormalDistributionDesignVariable(distribution);
// Call
var properties = new NormalDistributionDesignVariableProperties(DistributionReadOnlyProperties.All,
designVariable,
handler);
// Assert
Assert.IsInstanceOf <DesignVariableProperties <NormalDistribution> >(properties);
Assert.AreSame(distribution, properties.Data);
Assert.AreEqual(distribution.Mean, properties.Mean);
Assert.AreEqual(distribution.StandardDeviation, properties.StandardDeviation);
Assert.AreEqual("Normaal", properties.DistributionType);
mockRepository.VerifyAll();
}
public void PhreaticLevelExit_SetNewValue_UpdateMeanAndStandardDeviation()
{
// Setup
var random = new Random(22);
var input = new TestPipingInput();
var mean = (RoundedDouble)(0.01 + random.NextDouble());
var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
var expectedDistribution = new NormalDistribution(3)
{
Mean = mean,
StandardDeviation = standardDeviation
};
var distributionToSet = new NormalDistribution(5)
{
Mean = mean,
StandardDeviation = standardDeviation
};
// Call
input.PhreaticLevelExit = distributionToSet;
// Assert
DistributionTestHelper.AssertDistributionCorrectlySet(input.PhreaticLevelExit, distributionToSet, expectedDistribution);
}
public static float Calculate(Weapon weapon, float rawDamage)
{
var damagePerShot = weapon.DamagePerShot;
var adjustment = rawDamage / damagePerShot;
var variance = weapon.weaponDef.DamageVariance;
var roll = NormalDistribution.Random(
new VarianceBounds(
damagePerShot - variance,
damagePerShot + variance,
Core.ModSettings.StandardDeviationSimpleVarianceMultiplier * variance
));
var variantDamage = roll * adjustment;
var sb = new StringBuilder();
sb.AppendLine($"roll: {roll}");
sb.AppendLine($"damagePerShot: {damagePerShot}");
sb.AppendLine($"variance: {variance}");
sb.AppendLine($"adjustment: {adjustment}");
sb.AppendLine($"variantDamage: {variantDamage}");
Logger.Debug(sb.ToString());
return(variantDamage);
}
/**
* Generate a new ARTA-Process with the given parameters.
* */
public ArProcess(double[] alphas, NormalDistribution whiteNoiseProcess)
{
this.alphas = alphas;
this.values = new DoubleHistory(alphas.Length);
this.whiteNoiseProcess = whiteNoiseProcess;
}
public static double Sample(StdRandom random, double mu, double sigma) => Math.Exp(NormalDistribution.Sample(random, mu, sigma));
//---------------------------------------------------------------------
///<summary>
/// Run the Biomass Insects extension at a particular timestep.
///</summary>
public override void Run()
{
running = true;
UI.WriteLine(" Processing landscape for Biomass Insect events ...");
foreach(IInsect insect in manyInsect)
{
if(insect.MortalityYear == Model.Core.CurrentTime)
Outbreak.Mortality(insect);
// Copy the data from current to last
foreach (ActiveSite site in Model.Core.Landscape)
insect.LastYearDefoliation[site] = insect.ThisYearDefoliation[site];
insect.ThisYearDefoliation.ActiveSiteValues = 0.0;
//SiteVars.BiomassRemoved.ActiveSiteValues = 0;
insect.ActiveOutbreak = false;
insect.SingleOutbreakYear = false;
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = 0; // mean
randVar.Sigma = 1; // std dev
double randomNum = randVar.NextDouble();
ExponentialDistribution randVarE = new ExponentialDistribution(RandomNumberGenerator.Singleton);
randVarE.Lambda = insect.MeanDuration; // rate
double randomNumE = randVarE.NextDouble();
// First, has enough time passed since the last outbreak?
double timeBetweenOutbreaks = insect.MeanTimeBetweenOutbreaks + (insect.StdDevTimeBetweenOutbreaks * randomNum);
//double duration = insect.MeanDuration + (insect.StdDevDuration * randomNum);
double duration = Math.Round(randomNumE + 1);
if (duration > 5) // Limit maximum outbreak duration to 5 years for now.
duration = duration - 3;
double timeAfterDuration = timeBetweenOutbreaks - duration;
//UI.WriteLine("Calculated time between = {0}. inputMeanTime={1}, inputStdTime={2}.", timeBetweenOutbreaks, insect.MeanTimeBetweenOutbreaks, insect.StdDevTimeBetweenOutbreaks);
//UI.WriteLine("Calculated duration = {0}. inputMeanDura={1}, inputStdDura={2}.", duration, insect.MeanDuration, insect.StdDevDuration);
//UI.WriteLine("Insect Start Time = {0}, Stop Time = {1}.", insect.OutbreakStartYear, insect.OutbreakStopYear);
if(Model.Core.CurrentTime == 1)
{
//UI.WriteLine(" Year 1: Setting initial start and stop times.");
insect.OutbreakStartYear = (int) (timeBetweenOutbreaks / 2.0) + 1;
insect.OutbreakStopYear = insect.OutbreakStartYear + (int) duration - 1;
UI.WriteLine(" {0} is not active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);
}
else if(insect.OutbreakStartYear <= Model.Core.CurrentTime
&& insect.OutbreakStopYear > Model.Core.CurrentTime)
{
//UI.WriteLine(" An outbreak starts or continues. Start and stop time do not change.");
insect.ActiveOutbreak = true;
UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);
insect.MortalityYear = Model.Core.CurrentTime + 1;
}
//Special case for single year outbreak.
else if(insect.OutbreakStartYear <= Model.Core.CurrentTime
&& insect.OutbreakStopYear <= Model.Core.CurrentTime)
{
insect.ActiveOutbreak = true;
UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);
if (insect.OutbreakStartYear == insect.OutbreakStopYear)
insect.SingleOutbreakYear = true;
insect.MortalityYear = Model.Core.CurrentTime + 1;
insect.OutbreakStartYear = Model.Core.CurrentTime + (int)timeBetweenOutbreaks;
insect.OutbreakStopYear = insect.OutbreakStartYear + (int)duration - 1;
}
else if(insect.OutbreakStopYear <= Model.Core.CurrentTime
&& timeAfterDuration > Model.Core.CurrentTime - insect.OutbreakStopYear)
{
//UI.WriteLine(" In between outbreaks, reset start and stop times.");
insect.ActiveOutbreak = true;
UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, Model.Core.CurrentTime);
insect.MortalityYear = Model.Core.CurrentTime + 1;
insect.OutbreakStartYear = Model.Core.CurrentTime + (int) timeBetweenOutbreaks;
insect.OutbreakStopYear = insect.OutbreakStartYear + (int) duration - 1;
}
//UI.WriteLine(" Insect Start Time = {0}, Stop Time = {1}.", insect.OutbreakStartYear, insect.OutbreakStopYear);
if(insect.ActiveOutbreak)
{
//UI.WriteLine(" OutbreakStartYear={0}.", insect.OutbreakStartYear);
if(insect.OutbreakStartYear == Model.Core.CurrentTime || insect.SingleOutbreakYear)
// Initialize neighborhoodGrowthReduction with patches
Outbreak.InitializeDefoliationPatches(insect);
else
insect.NeighborhoodDefoliation.ActiveSiteValues = 0;
double sumDefoliation = 0.0;
int numSites = 0;
//foreach(ActiveSite site in Model.Core.Landscape)
//{
// sumDefoliation += insect.ThisYearDefoliation[site];
// if(insect.ThisYearDefoliation[site] > 0.0)
// numSites++;
//}
double meanDefoliation = sumDefoliation / (double) numSites;
log.Write("{0},{1},{2},{3},{4},{5}",
Model.Core.CurrentTime,
insect.Name,
insect.OutbreakStartYear,
insect.OutbreakStopYear,
sumDefoliation,
numSites
);
//foreach (IEcoregion ecoregion in Ecoregions.Dataset)
// log.Write(",{0}", 1);
log.WriteLine("");
}
//Only write maps if an outbreak is active.
//if (!insect.ActiveOutbreak)
//if (insect.OutbreakStartYear <= Model.Core.CurrentTime
// && insect.OutbreakStopYear + 1 >= Model.Core.CurrentTime)
//if (insect.OutbreakStartYear <= Model.Core.CurrentTime)
// | insect.MortalityYear = Model.Core.CurrentTime)
// continue;
//----- Write Insect GrowthReduction maps --------
IOutputRaster<UShortPixel> map = CreateMap((Model.Core.CurrentTime - 1), insect.Name);
using (map) {
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive)
pixel.Band0 = (ushort) (insect.LastYearDefoliation[site] * 100.0);
else
// Inactive site
pixel.Band0 = 0;
map.WritePixel(pixel);
}
}
//----- Write Initial Patch maps --------
//IOutputRaster<UShortPixel> map2 = CreateMap(Model.Core.CurrentTime, ("InitialPatchMap" + insect.Name));
//using (map2) {
// UShortPixel pixel = new UShortPixel();
// foreach (Site site in Model.Core.Landscape.AllSites) {
// if (site.IsActive)
// {
// if (insect.Disturbed[site])
// pixel.Band0 = (ushort) (SiteVars.InitialOutbreakProb[site] * 100);
// else
// pixel.Band0 = 0;
// }
// else
// {
// // Inactive site
// pixel.Band0 = 0;
// }
// map2.WritePixel(pixel);
// }
//}
//----- Write Biomass Reduction maps --------
IOutputRaster<UShortPixel> map3 = CreateMap(Model.Core.CurrentTime, ("BiomassRemoved" + insect.Name));
using (map3) {
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive)
{
// TESTING added by RMS
if(SiteVars.BiomassRemoved[site] > 0)
// UI.WriteLine(" Biomass revoved at {0}/{1}: {2}.", site.Location.Row, site.Location.Column, SiteVars.BiomassRemoved[site]);
pixel.Band0 = (ushort) (SiteVars.BiomassRemoved[site] / 100);
else
pixel.Band0 = 0;
}
else
{
// Inactive site
pixel.Band0 = 0;
}
map3.WritePixel(pixel);
//Zero out the BiomassRemoved after the last insect mortality event in a given year.
//if (SiteVars.BiomassRemoved[site] > 0 && SiteVars.TimeOfLastEvent[site] < Model.Core.CurrentTime)
SiteVars.BiomassRemoved[site] = 0;
}
}
}
}
public void DistributionFunctionTest3()
{
double expected, actual;
// Test small variance
NormalDistribution target = new NormalDistribution(1.0, double.Epsilon);
expected = 0;
actual = target.DistributionFunction(0);
Assert.AreEqual(expected, actual);
expected = 0.5;
actual = target.DistributionFunction(1.0);
Assert.AreEqual(expected, actual);
expected = 1.0;
actual = target.DistributionFunction(1.0 + 1e-15);
Assert.AreEqual(expected, actual);
expected = 0.0;
actual = target.DistributionFunction(1.0 - 1e-15);
Assert.AreEqual(expected, actual);
}
public NormalRandomGenerator(NormalDistribution distribution)
{
this.distribution = distribution;
}
public NormalRandomGenerator(Random random, NormalDistribution distribution) : base(random)
{
this.distribution = distribution;
}
public void MedianTest()
{
NormalDistribution target = new NormalDistribution(0.4, 2.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
/// <summary>
/// Validate inverse cumulative distribution.
/// </summary>
/// <param name="x">Input X value.</param>
/// <param name="p">Expected value.</param>
public void ValidateInverseCumulativeDistribution(double x, double p)
{
var n = new NormalDistribution(5.0, 2.0);
Assert.AreEqual(x, n.InverseCumulativeDistribution(p), 14);
}
public void GenerateTest()
{
NormalDistribution target = new NormalDistribution(2, 5);
double[] samples = target.Generate(1000000);
var actual = NormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(2, actual.Mean, 0.01);
Assert.AreEqual(5, actual.StandardDeviation, 0.01);
}
public void GenerateTest2()
{
NormalDistribution target = new NormalDistribution(4, 2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
samples[i] = target.Generate();
var actual = NormalDistribution.Estimate(samples);
actual.Fit(samples);
Assert.AreEqual(4, actual.Mean, 0.01);
Assert.AreEqual(2, actual.StandardDeviation, 0.01);
}
public void CloneTest()
{
NormalDistribution target = new NormalDistribution(0.5, 4.2);
NormalDistribution clone = (NormalDistribution)target.Clone();
Assert.AreNotSame(target, clone);
Assert.AreEqual(target.Entropy, clone.Entropy);
Assert.AreEqual(target.Mean, clone.Mean);
Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
Assert.AreEqual(target.Variance, clone.Variance);
}
public void ZScoreTest()
{
double x = 5;
double mean = 3;
double dev = 6;
NormalDistribution target = new NormalDistribution(mean, dev);
double expected = (x - 3) / 6;
double actual = target.ZScore(x);
Assert.AreEqual(expected, actual);
}
public void InverseDistributionFunctionTest()
{
double[] expected =
{
Double.NegativeInfinity, -4.38252, -2.53481, -1.20248,
-0.0640578, 1.0, 2.06406, 3.20248, 4.53481, 6.38252,
Double.PositiveInfinity
};
NormalDistribution target = new NormalDistribution(1.0, 4.2);
for (int i = 0; i < expected.Length; i++)
{
double x = i / 10.0;
double actual = target.InverseDistributionFunction(x);
Assert.AreEqual(expected[i], actual, 1e-5);
Assert.IsFalse(Double.IsNaN(actual));
}
}
///<summary>
///</summary>
///<param name="boughtSold"></param>
///<param name="settled"></param>
///<param name="rateRenamed"></param>
///<param name="maturity"></param>
///<param name="tenor"></param>
///<param name="time"></param>
///<param name="ci"></param>
///<param name="volatility"></param>
///<param name="reversion"></param>
///<returns></returns>
///<exception cref="Exception"></exception>
///<exception cref="NotSupportedException"></exception>
public static double AltSwaptionPCE(string boughtSold,
string settled,
double rateRenamed,
double maturity,
double tenor,
double time,
double ci,
double volatility,
double reversion)
{
//redenominate in years
double mmaturity = maturity / 365.0;
double ttime = time / 365.0;
double ttenor = tenor / 365.0;
double srs = volatility * Math.Sqrt((1.0 - Math.Exp(-2 * reversion * ttime)) / (2 * reversion));
//GEIS' U1
double srt = volatility * Math.Sqrt((1.0 - Math.Exp(-2 * reversion * mmaturity)) / (2 * reversion));
//GEIS' U2
double altswaptionPCE;
switch (boughtSold)
{
case "Bought":
if (time < maturity)
{
altswaptionPCE = Math.Pow((1.0 + rateRenamed), (ttime - mmaturity)) * (1.0 - Math.Pow((1 + rateRenamed), -ttenor)) * (1.0 - Math.Exp(-ci * srs));
}
else if ((time >= maturity) && (time < (maturity + tenor)))
{
//branch on settlement type
switch (settled)
{
case "Physical":
altswaptionPCE = (1.0 - Math.Pow((1.0 + rateRenamed), (ttime - mmaturity - ttenor))) * (1.0 - Math.Exp(-ci * srs));
break;
case "Cash":
altswaptionPCE = 0.0D;
break;
default:
throw new Exception("Swaption settlement type: " + settled + " Unknown");
}
}
else
{
//must be on or beyond maturity + tenor...
altswaptionPCE = 0.0D;
}
break;
case "Sold":
if (time < maturity)
{
altswaptionPCE = 0.0D;
}
else if ((time >= maturity) && (time < (maturity + tenor)))
{
switch (settled)
{
case "Physical":
//*****************************************
// Tem1 = Application.NormSDist(srt)
// *****************************************
double tem1 = NormalDistribution.Probability(srt);
double srst = volatility * Math.Sqrt((1.0 - Math.Exp(-2 * reversion * (ttime - mmaturity))) / (2 * reversion));
double tem2 = Math.Exp(volatility * volatility * mmaturity / 2 - srst * ci);
double tem3 = 1.0 - Math.Pow((1.0 + rateRenamed), (ttime - mmaturity - ttenor));
altswaptionPCE = (1.0 - 2 * tem1 * tem2) * tem3;
if (altswaptionPCE < 0)
{
altswaptionPCE = 0.0D;
}
break;
case "Cash":
altswaptionPCE = 0.0D;
break;
default:
throw new Exception("Swaption settlement type: " + settled + " Unknown");
}
}
else
{
//outside range of interest, so.....
altswaptionPCE = 0.0D;
}
break;
default:
throw new NotSupportedException(boughtSold + " not implemented as a Boughtsold value");
}
return(altswaptionPCE);
}
public void RiskStatisticsTest()
{
// ("Testing risk measures...");
IncrementalGaussianStatistics igs = new IncrementalGaussianStatistics();
RiskStatistics s = new RiskStatistics();
double[] averages = { -100.0, -1.0, 0.0, 1.0, 100.0 };
double[] sigmas = { 0.1, 1.0, 100.0 };
int i, j, k, N;
N = (int)Math.Pow(2, 16) - 1;
double dataMin, dataMax;
List <double> data = new InitializedList <double>(N), weights = new InitializedList <double>(N);
for (i = 0; i < averages.Length; i++)
{
for (j = 0; j < sigmas.Length; j++)
{
NormalDistribution normal = new NormalDistribution(averages[i], sigmas[j]);
CumulativeNormalDistribution cumulative = new CumulativeNormalDistribution(averages[i], sigmas[j]);
InverseCumulativeNormal inverseCum = new InverseCumulativeNormal(averages[i], sigmas[j]);
SobolRsg rng = new SobolRsg(1);
dataMin = double.MaxValue;
dataMax = double.MinValue;
for (k = 0; k < N; k++)
{
data[k] = inverseCum.value(rng.nextSequence().value[0]);
dataMin = Math.Min(dataMin, data[k]);
dataMax = Math.Max(dataMax, data[k]);
weights[k] = 1.0;
}
igs.addSequence(data, weights);
s.addSequence(data, weights);
// checks
double calculated, expected;
double tolerance;
if (igs.samples() != N)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong number of samples\n"
+ " calculated: " + igs.samples() + "\n"
+ " expected: " + N);
}
if (s.samples() != N)
{
QAssert.Fail("RiskStatistics: wrong number of samples\n"
+ " calculated: " + s.samples() + "\n"
+ " expected: " + N);
}
// weightSum()
tolerance = 1e-10;
expected = weights.Sum();
calculated = igs.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// min
tolerance = 1e-12;
expected = dataMin;
calculated = igs.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// max
expected = dataMax;
calculated = igs.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// mean
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-13 :
Math.Abs(expected) * 1.0e-13);
calculated = igs.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// variance
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// standardDeviation
expected = sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// missing errorEstimate() test
// skewness
expected = 0.0;
tolerance = 1.0e-4;
calculated = igs.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// kurtosis
expected = 0.0;
tolerance = 1.0e-1;
calculated = igs.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// percentile
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.percentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// potential upside
double upper_tail = averages[i] + 2.0 * sigmas[j],
lower_tail = averages[i] - 2.0 * sigmas[j];
double twoSigma = cumulative.value(upper_tail);
expected = Math.Max(upper_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.potentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// just to check that GaussianStatistics<StatsHolder> does work
StatsHolder h = new StatsHolder(s.mean(), s.standardDeviation());
GenericGaussianStatistics <StatsHolder> test = new GenericGaussianStatistics <StatsHolder>(h);
expected = s.gaussianPotentialUpside(twoSigma);
calculated = test.gaussianPotentialUpside(twoSigma);
if (calculated != expected)
{
QAssert.Fail("GenericGaussianStatistics<StatsHolder> fails"
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
// value-at-risk
expected = -Math.Min(lower_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.valueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
if (averages[i] > 0.0 && sigmas[j] < averages[i])
{
// no data will miss the targets:
// skip the rest of this iteration
igs.reset();
s.reset();
continue;
}
// expected shortfall
expected = -Math.Min(averages[i]
- sigmas[j] * sigmas[j]
* normal.value(lower_tail) / (1.0 - twoSigma),
0.0);
tolerance = (expected == 0.0 ? 1.0e-4
: Math.Abs(expected) * 1.0e-2);
calculated = igs.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.expectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// shortfall
expected = 0.5;
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.shortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// average shortfall
expected = sigmas[j] / Math.Sqrt(2.0 * Const.M_PI) * 2.0;
tolerance = expected * 1.0e-3;
calculated = igs.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.averageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// regret
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.regret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
expected = s.downsideVariance();
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
if (averages[i] == 0.0)
{
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-3;
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
}
igs.reset();
s.reset();
}
}
}
public void MixtureDistributionExample()
{
var samples1 = new NormalDistribution(mean: -2, stdDev: 1).Generate(100000);
var samples2 = new NormalDistribution(mean: +4, stdDev: 1).Generate(100000);
// Mix the samples from both distributions
var samples = samples1.Concatenate(samples2);
// Create a new mixture distribution with two Normal components
var mixture = new Mixture<NormalDistribution>(
new NormalDistribution(-1),
new NormalDistribution(+1));
// Estimate the distribution
mixture.Fit(samples);
var a = mixture.Components[0].ToString("N2"); // N(x; μ = -2.00, σ² = 1.00)
var b = mixture.Components[1].ToString("N2"); // N(x; μ = 4.00, σ² = 1.02)
Assert.AreEqual("N(x; μ = -2.00, σ² = 1.00)", a);
Assert.AreEqual("N(x; μ = 4.00, σ² = 1.02)", b);
}
public void FitTest()
{
double expectedMean = 1.125;
double expectedSigma = 1.01775897605147;
NormalDistribution target;
target = new NormalDistribution();
double[] observations = { 0.10, 0.40, 2.00, 2.00 };
double[] weights = { 0.25, 0.25, 0.25, 0.25 };
target.Fit(observations, weights);
Assert.AreEqual(expectedMean, target.Mean);
Assert.AreEqual(expectedSigma, target.StandardDeviation, 1e-6);
target = new NormalDistribution();
double[] observations2 = { 0.10, 0.10, 0.40, 2.00 };
double[] weights2 = { 0.125, 0.125, 0.25, 0.50 };
target.Fit(observations2, weights2);
Assert.AreEqual(expectedMean, target.Mean);
}
public DerivedNormalDistribution(NormalDistribution distribution)
{
Mean = distribution.Mean;
StandardDeviation = distribution.StandardDeviation;
}
public void PredictTest2()
{
// Create continuous sequences. In the sequence below, there
// seems to be two states, one for values equal to 1 and another
// for values equal to 2.
double[][] sequences = new double[][]
{
new double[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2 }
};
// Specify a initial normal distribution for the samples.
NormalDistribution density = new NormalDistribution();
// Creates a continuous hidden Markov Model with two states organized in a forward
// topology and an underlying univariate Normal distribution as probability density.
var model = new HiddenMarkovModel<NormalDistribution>(new Ergodic(2), density);
// Configure the learning algorithms to train the sequence classifier until the
// difference in the average log-likelihood changes only by as little as 0.0001
var teacher = new BaumWelchLearning<NormalDistribution>(model)
{
Tolerance = 0.0001,
Iterations = 0,
// However, we will need to specify a regularization constant as the
// variance of each state will likely be zero (all values are equal)
FittingOptions = new NormalOptions() { Regularization = double.Epsilon }
};
// Fit the model
double likelihood = teacher.Run(sequences);
double a1 = model.Predict(new double[] { 1, 2, 1 });
double a2 = model.Predict(new double[] { 1, 2, 1, 2 });
Assert.AreEqual(2, a1, 1e-10);
Assert.AreEqual(1, a2, 1e-10);
Assert.IsFalse(Double.IsNaN(a1));
Assert.IsFalse(Double.IsNaN(a2));
double p1, p2;
Mixture<NormalDistribution> d1, d2;
double b1 = model.Predict(new double[] { 1, 2, 1 }, out p1, out d1);
double b2 = model.Predict(new double[] { 1, 2, 1, 2 }, out p2, out d2);
Assert.AreEqual(2, b1, 1e-10);
Assert.AreEqual(1, b2, 1e-10);
Assert.IsFalse(Double.IsNaN(b1));
Assert.IsFalse(Double.IsNaN(b2));
Assert.AreEqual(0, d1.Coefficients[0]);
Assert.AreEqual(1, d1.Coefficients[1]);
Assert.AreEqual(1, d2.Coefficients[0]);
Assert.AreEqual(0, d2.Coefficients[1]);
}
public NormalRandomGenerator(int seed, NormalDistribution distribution) : base(seed)
{
this.distribution = distribution;
}
public void LearnTest7()
{
// Create continuous sequences. In the sequences below, there
// seems to be two states, one for values between 0 and 1 and
// another for values between 5 and 7. The states seems to be
// switched on every observation.
double[][] sequences = new double[][]
{
new double[] { 0.1, 5.2, 0.3, 6.7, 0.1, 6.0 },
new double[] { 0.2, 6.2, 0.3, 6.3, 0.1, 5.0 },
new double[] { 0.1, 7.0, 0.1, 7.0, 0.2, 5.6 },
};
// Specify a initial normal distribution for the samples.
var density = new NormalDistribution();
// Creates a continuous hidden Markov Model with two states organized in a forward
// topology and an underlying univariate Normal distribution as probability density.
var model = new HiddenMarkovModel<NormalDistribution>(new Ergodic(2), density);
// Configure the learning algorithms to train the sequence classifier until the
// difference in the average log-likelihood changes only by as little as 0.0001
var teacher = new BaumWelchLearning<NormalDistribution>(model)
{
Tolerance = 0.0001,
Iterations = 0,
};
// Fit the model
double logLikelihood = teacher.Run(sequences);
// See the log-probability of the sequences learned
double a1 = model.Evaluate(new[] { 0.1, 5.2, 0.3, 6.7, 0.1, 6.0 }); // -0.12799388666109757
double a2 = model.Evaluate(new[] { 0.2, 6.2, 0.3, 6.3, 0.1, 5.0 }); // 0.01171157434400194
// See the probability of an unrelated sequence
double a3 = model.Evaluate(new[] { 1.1, 2.2, 1.3, 3.2, 4.2, 1.0 }); // -298.7465244473417
double likelihood = Math.Exp(logLikelihood);
a1 = Math.Exp(a1); // 0.879
a2 = Math.Exp(a2); // 1.011
a3 = Math.Exp(a3); // 0.000
// We can also ask the model to decode one of the sequences. After
// this step the resulting sequence will be: { 0, 1, 0, 1, 0, 1 }
//
int[] states = model.Decode(new[] { 0.1, 5.2, 0.3, 6.7, 0.1, 6.0 });
Assert.IsTrue(states.IsEqual(0, 1, 0, 1, 0, 1));
Assert.AreEqual(1.1341500279562791, likelihood, 1e-10);
Assert.AreEqual(0.8798587580029778, a1, 1e-10);
Assert.AreEqual(1.0117804233450216, a2, 1e-10);
Assert.AreEqual(1.8031545195073828E-130, a3, 1e-10);
Assert.IsFalse(double.IsNaN(logLikelihood));
Assert.IsFalse(double.IsNaN(a1));
Assert.IsFalse(double.IsNaN(a2));
Assert.IsFalse(double.IsNaN(a3));
Assert.AreEqual(2, model.Emissions.Length);
var state1 = (model.Emissions[0] as NormalDistribution);
var state2 = (model.Emissions[1] as NormalDistribution);
Assert.AreEqual(0.16666666666666, state1.Mean, 1e-10);
Assert.AreEqual(6.11111111111111, state2.Mean, 1e-10);
Assert.IsFalse(Double.IsNaN(state1.Mean));
Assert.IsFalse(Double.IsNaN(state2.Mean));
Assert.AreEqual(0.007499999999999, state1.Variance, 1e-10);
Assert.AreEqual(0.538611111111111, state2.Variance, 1e-10);
Assert.IsFalse(Double.IsNaN(state1.Variance));
Assert.IsFalse(Double.IsNaN(state2.Variance));
Assert.AreEqual(2, model.Transitions.GetLength(0));
Assert.AreEqual(2, model.Transitions.GetLength(1));
var A = Matrix.Exp(model.Transitions);
Assert.AreEqual(0, A[0, 0], 1e-16);
Assert.AreEqual(1, A[0, 1], 1e-16);
Assert.AreEqual(1, A[1, 0], 1e-16);
Assert.AreEqual(0, A[1, 1], 1e-16);
Assert.IsFalse(A.HasNaN());
}
public void Compute(OptionPosition option)
{
var t = option.TimeToExpiry.TotalDays / 365.0;
if (Math.Abs(t) < Double.Epsilon)
{
return;
}
var d1 = Math.Log(option.UnderlyingPrice / option.Strike) + (option.InterestRate - option.DividendRate + Math.Pow(option.Volatility, 2)) / t;
var d2 = d1 - option.Volatility * Math.Sqrt(t);
// when calculating option greeks keep in mind that we calculate greek for position,
// and that's why BS formulas for greeks must be multiplied by -1 in case we're selling options
// so formulas for greeks are [sign * BSFormula]
if (option.Type == OptionType.Call)
{
option.OptionPrice = option.UnderlyingPrice * NormalDistribution.Phi(d1) -
option.Strike * Math.Exp(-option.InterestRate * t) * NormalDistribution.Phi(d2);
option.Delta = Math.Exp(-option.DividendRate * t) * NormalDistribution.Phi(d1);
option.Theta = -Math.Exp(-option.DividendRate * t) * option.UnderlyingPrice * NormalDistribution.Density(d1) *
option.Volatility / (2 * Math.Sqrt(t))
+
option.DividendRate * Math.Exp(-option.DividendRate * t) * option.UnderlyingPrice *
NormalDistribution.Phi(d1)
-
option.InterestRate * option.Strike * Math.Exp(-option.InterestRate * t) *
NormalDistribution.Phi(d2);
option.Rho = t * option.Strike * Math.Exp(-option.InterestRate * t) * NormalDistribution.Phi(d2);
}
else
{
option.OptionPrice = -option.UnderlyingPrice * NormalDistribution.Phi(-d1) +
option.Strike * Math.Exp(-option.InterestRate * t) * NormalDistribution.Phi(-d2);
option.Delta = Math.Exp(-option.DividendRate * t) * (NormalDistribution.Phi(d1) - 1);
option.Theta = -Math.Exp(-option.DividendRate * t) * option.UnderlyingPrice * NormalDistribution.Density(d1) *
option.Volatility / (2 * Math.Sqrt(t))
-
option.DividendRate * Math.Exp(-option.DividendRate * t) * option.UnderlyingPrice *
NormalDistribution.Phi(-d1)
+
option.InterestRate * option.Strike * Math.Exp(-option.InterestRate * t) *
NormalDistribution.Phi(-d2);
option.Rho = -t *option.Strike *Math.Exp(-option.InterestRate *t) * NormalDistribution.Phi(-d2);
}
option.Gamma = Math.Exp(-option.DividendRate * t) * NormalDistribution.Density(d1) /
(option.UnderlyingPrice * option.Volatility * Math.Sqrt(t));
option.Vega = Math.Exp(-option.DividendRate * t) * option.UnderlyingPrice * NormalDistribution.Density(d1) *
Math.Sqrt(t);
SideHelper.FixGreeksAccordingToSide(option);
}
public void LearnTest8()
{
// Create continuous sequences. In the sequence below, there
// seems to be two states, one for values equal to 1 and another
// for values equal to 2.
double[][] sequences = new double[][]
{
new double[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2 }
};
// Specify a initial normal distribution for the samples.
var density = new NormalDistribution();
// Creates a continuous hidden Markov Model with two states organized in a forward
// topology and an underlying univariate Normal distribution as probability density.
var model = new HiddenMarkovModel<NormalDistribution>(new Ergodic(2), density);
// Configure the learning algorithms to train the sequence classifier until the
// difference in the average log-likelihood changes only by as little as 0.0001
var teacher = new BaumWelchLearning<NormalDistribution>(model)
{
Tolerance = 0.0001,
Iterations = 0,
// However, we will need to specify a regularization constant as the
// variance of each state will likely be zero (all values are equal)
FittingOptions = new NormalOptions() { Regularization = double.Epsilon }
};
// Fit the model
double likelihood = teacher.Run(sequences);
// See the probability of the sequences learned
double a1 = model.Evaluate(new double[] { 1, 2, 1, 2, 1, 2, 1, 2, 1 }); // exp(a1) = inf
double a2 = model.Evaluate(new double[] { 1, 2, 1, 2, 1 }); // exp(a2) = inf
// See the probability of an unrelated sequence
double a3 = model.Evaluate(new double[] { 1, 2, 3, 2, 1, 2, 1 }); // exp(a3) = 0
double a4 = model.Evaluate(new double[] { 1.1, 2.2, 1.3, 3.2, 4.2, 1.0 }); // exp(a4) = 0
Assert.AreEqual(double.PositiveInfinity, System.Math.Exp(likelihood));
Assert.AreEqual(302.59496915947972, a1);
Assert.AreEqual(168.26234890650207, a2);
Assert.AreEqual(0.0, Math.Exp(a3));
Assert.AreEqual(0.0, Math.Exp(a4));
Assert.AreEqual(2, model.Emissions.Length);
var state1 = (model.Emissions[0] as NormalDistribution);
var state2 = (model.Emissions[1] as NormalDistribution);
Assert.AreEqual(1.0, state1.Mean, 1e-10);
Assert.AreEqual(2.0, state2.Mean, 1e-10);
Assert.IsFalse(Double.IsNaN(state1.Mean));
Assert.IsFalse(Double.IsNaN(state2.Mean));
Assert.IsTrue(state1.Variance < 1e-30);
Assert.IsTrue(state2.Variance < 1e-30);
var A = Matrix.Exp(model.Transitions);
Assert.AreEqual(2, A.GetLength(0));
Assert.AreEqual(2, A.GetLength(1));
Assert.AreEqual(0, A[0, 0]);
Assert.AreEqual(1, A[0, 1]);
Assert.AreEqual(1, A[1, 0]);
Assert.AreEqual(0, A[1, 1]);
}
/// <summary>
/// Generic learn method implementation that should work for any input type.
/// This method is useful for re-using code between methods that accept Bitmap,
/// BitmapData, UnmanagedImage, filenames as strings, etc.
/// </summary>
///
/// <typeparam name="T">The input type.</typeparam>
///
/// <param name="x">The inputs.</param>
/// <param name="weights">The weights.</param>
/// <param name="extractor">A function that knows how to process the input
/// and extract features from them.</param>
///
/// <returns>The trained model.</returns>
///
protected TModel InnerLearn <T>(T[] x, double[] weights,
Func <T, TExtractor, IEnumerable <TPoint> > extractor)
{
var descriptorsPerInstance = new TFeature[x.Length][];
var totalDescriptorCounts = new double[x.Length];
int takenDescriptorCount = 0;
// For all instances
For(0, x.Length, (i, detector) =>
{
if (NumberOfDescriptors > 0 && takenDescriptorCount >= NumberOfDescriptors)
{
return;
}
TFeature[] desc = extractor(x[i], detector).Select(p => p.Descriptor).ToArray();
totalDescriptorCounts[i] = desc.Length;
if (MaxDescriptorsPerInstance > 0)
{
desc = desc.Sample(MaxDescriptorsPerInstance);
}
Interlocked.Add(ref takenDescriptorCount, desc.Length);
descriptorsPerInstance[i] = desc;
});
if (NumberOfDescriptors >= 0 && takenDescriptorCount < NumberOfDescriptors)
{
throw new InvalidOperationException("There were not enough descriptors to sample the desired amount " +
"of samples ({0}). Please either increase the number of images, or increase the number of ".Format(NumberOfDescriptors) +
"descriptors that are sampled from each image by adjusting the MaxSamplesPerImage property ({0}).".Format(MaxDescriptorsPerInstance));
}
var totalDescriptors = new TFeature[takenDescriptorCount];
var totalWeights = weights != null ? new double[takenDescriptorCount] : null;
int[] instanceIndices = new int[takenDescriptorCount];
int c = 0, w = 0;
for (int i = 0; i < descriptorsPerInstance.Length; i++)
{
if (descriptorsPerInstance[i] != null)
{
if (weights != null)
{
totalWeights[w++] = weights[i];
}
for (int j = 0; j < descriptorsPerInstance[i].Length; j++)
{
totalDescriptors[c] = descriptorsPerInstance[i][j];
instanceIndices[c] = i;
c++;
}
}
}
if (NumberOfDescriptors > 0)
{
int[] idx = Vector.Sample(NumberOfDescriptors);
totalDescriptors = totalDescriptors.Get(idx);
instanceIndices = instanceIndices.Get(idx);
}
int[] hist = instanceIndices.Histogram();
Debug.Assert(hist.Sum() == (NumberOfDescriptors > 0 ? NumberOfDescriptors : takenDescriptorCount));
this.Statistics = new BagOfWordsStatistics()
{
TotalNumberOfInstances = x.Length,
TotalNumberOfDescriptors = (int)totalDescriptorCounts.Sum(),
TotalNumberOfDescriptorsPerInstance = NormalDistribution.Estimate(totalDescriptorCounts, new NormalOptions {
Robust = true
}),
TotalNumberOfDescriptorsPerInstanceRange = new IntRange((int)totalDescriptorCounts.Min(), (int)totalDescriptorCounts.Max()),
NumberOfInstancesTaken = hist.Length,
NumberOfDescriptorsTaken = totalDescriptors.Length,
NumberOfDescriptorsTakenPerInstance = NormalDistribution.Estimate(hist.ToDouble(), new NormalOptions {
Robust = true
}),
NumberOfDescriptorsTakenPerInstanceRange = new IntRange(hist.Min(), hist.Max())
};
return(learn(totalDescriptors, totalWeights));
}
public void DistributionFunctionTest()
{
double x = 3;
double mean = 7;
double dev = 5;
NormalDistribution target = new NormalDistribution(mean, dev);
double expected = 0.211855398583397;
double actual = target.DistributionFunction(x);
Assert.IsFalse(double.IsNaN(actual));
Assert.AreEqual(expected, actual, 1e-15);
}
/// <summary>
/// Validate cumulative distribution.
/// </summary>
/// <param name="x">Input X value.</param>
/// <param name="p">Expected value.</param>
public void ValidateCumulativeDistribution(double x, double p)
{
var n = new NormalDistribution(5.0, 2.0);
Assert.AreEqual(p, n.CumulativeDistribution(x), 9);
}
public void ProbabilityDensityFunctionTest2()
{
double expected, actual;
// Test for small variance
NormalDistribution target = new NormalDistribution(4.2, double.Epsilon);
expected = 0;
actual = target.ProbabilityDensityFunction(0);
Assert.AreEqual(expected, actual);
expected = double.PositiveInfinity;
actual = target.ProbabilityDensityFunction(4.2);
Assert.AreEqual(expected, actual);
}
private void DiamondSquare(ref float[,] data, int r, int y, int x, float sigma)
{
{
// Center
float avg = 0;
avg += data[y, x];
avg += data[y + r, x];
avg += data[y, x + r];
avg += data[y + r, x + r];
data[y + r / 2, x + r / 2] = NormalDistribution.Rand(avg / 4, sigma / Mathf.Sqrt(2));
}
{
// Left
float avg = 0;
avg += data[y, x];
avg += data[y + r / 2, x + r / 2];
avg += data[y + r, x];
if (x > 0)
{
avg += data[y, x - r / 2];
data[y + r / 2, x] = NormalDistribution.Rand(avg / 4, sigma / 2);
}
else
{
data[y + r / 2, x] = NormalDistribution.Rand(avg / 3, sigma / 2);
}
}
{
// Right
float avg = 0;
avg += data[y, x + r];
avg += data[y + r / 2, x + r / 2];
avg += data[y + r, x + r];
if ((x + r + 1) * (x + r + 1) < data.Length)
{
avg += data[y, x + r + r / 2];
data[y + r / 2, x + r] = NormalDistribution.Rand(avg / 4, sigma / 2);
}
else
{
data[y + r / 2, x + r] = NormalDistribution.Rand(avg / 3, sigma / 2);
}
}
{
// Top
float avg = 0;
avg += data[y, x];
avg += data[y + r / 2, x + r / 2];
avg += data[y, x + r];
if (y > 0)
{
avg += data[y - r / 2, x];
data[y, x + r / 2] = NormalDistribution.Rand(avg / 4, sigma / 2);
}
else
{
data[y, x + r / 2] = NormalDistribution.Rand(avg / 3, sigma / 2);
}
}
{
// Bottom
float avg = 0;
avg += data[y + r, x];
avg += data[y + r / 2, x + r / 2];
avg += data[y + r, x + r];
if ((y + r + 1) * (y + r + 1) < data.Length)
{
avg += data[y + r + r / 2, x];
data[y + r, x + r / 2] = NormalDistribution.Rand(avg / 4, sigma / 2);
}
else
{
data[y + r, x + r / 2] = NormalDistribution.Rand(avg / 3, sigma / 2);
}
}
}
public void LogProbabilityDensityFunctionTest()
{
double x = 3;
double mean = 7;
double dev = 5;
NormalDistribution target = new NormalDistribution(mean, dev);
double expected = System.Math.Log(0.0579383105522966);
double actual = target.LogProbabilityDensityFunction(x);
Assert.IsFalse(double.IsNaN(actual));
Assert.AreEqual(expected, actual, 1e-15);
}
