public void NaiveBayesConstructorTest4()
{
int classes = 2;
int inputCount = 3;
double[] priors = { 0.4, 0.6 };
UniformDiscreteDistribution initial = new UniformDiscreteDistribution(0, 3);
var target = new NaiveBayes <UniformDiscreteDistribution>(classes, inputCount, initial, priors);
Assert.AreEqual(classes, target.ClassCount);
Assert.AreEqual(inputCount, target.InputCount);
Assert.AreEqual(priors.Length, target.Priors.Length);
Assert.AreEqual(0.4, target.Priors[0]);
Assert.AreEqual(0.6, target.Priors[1]);
Assert.AreEqual(2, target.Distributions.GetLength(0));
Assert.AreEqual(3, target.Distributions.GetLength(1));
for (int i = 0; i < classes; i++)
{
for (int j = 0; j < inputCount; j++)
{
Assert.AreNotSame(initial, target.Distributions[i, j]);
Assert.AreEqual(0, target.Distributions[i, j].Minimum);
Assert.AreEqual(3, target.Distributions[i, j].Maximum);
}
}
}
protected override void EndProcessing()
{
var dist = new UniformDiscreteDistribution(Minimum, Maximum);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void insertion_sort_success()
{
for (int n = 1; n < 100; n += 10)
{
for (int i = 0; i < 100; i++)
{
int[] random = UniformDiscreteDistribution.Random(n);
double[] expected = random.ToDouble();
double[] a = random.ToDouble();
double[] b = random.ToDouble();
double[] c = random.ToDouble();
double[] d = random.ToDouble();
double[] e = random.ToDouble();
Array.Sort(expected);
Sort.Insertion(a);
Sort.Insertion(b, asc: false);
b = b.Reversed();
Sort.Insertion(c, asc: true);
Func <double, double, int> greater = (x, y) => - x.CompareTo(y);
Sort.Insertion(d, comparer: greater, asc: false);
Sort.Insertion(e, comparer: greater, asc: true);
e = e.Reversed();
Assert.IsTrue(expected.IsEqual(a));
Assert.IsTrue(expected.IsEqual(b));
Assert.IsTrue(expected.IsEqual(c));
Assert.IsTrue(expected.IsEqual(d));
Assert.IsTrue(expected.IsEqual(e));
}
}
}
public void bottom_1()
{
Accord.Math.Random.Generator.Seed = 0;
for (int size = 1; size < 1000; size *= 10)
{
for (int n = 1; n < size; n += 10)
{
for (int i = 0; i < 100; i++)
{
int[] random = UniformDiscreteDistribution.Random(size);
int[] sorted = random.Sorted();
int[] expectedBottom = sorted.First(n);
int[] bottomIdx = random.Bottom(n);
int[] actualBottom = random.Submatrix(bottomIdx);
Assert.IsTrue(actualBottom.IsEqual(expectedBottom));
int[] expectedTop = sorted.Last(n).Reversed();
int[] topIdx = random.Top(n);
int[] actualTop = random.Submatrix(topIdx);
Assert.IsTrue(actualTop.IsEqual(expectedTop));
}
}
}
}
public void ConstructorTest()
{
// Create an uniform (discrete) distribution in [2, 6]
var dist = new UniformDiscreteDistribution(a: 2, b: 6);
// Common measures
double mean = dist.Mean; // 4.0
double median = dist.Median; // 4.0
double var = dist.Variance; // 1.3333333333333333
// Cumulative distribution functions
double cdf = dist.DistributionFunction(k: 2); // 0.2
double ccdf = dist.ComplementaryDistributionFunction(k: 2); // 0.8
// Probability mass functions
double pmf1 = dist.ProbabilityMassFunction(k: 4); // 0.2
double pmf2 = dist.ProbabilityMassFunction(k: 5); // 0.2
double pmf3 = dist.ProbabilityMassFunction(k: 6); // 0.2
double lpmf = dist.LogProbabilityMassFunction(k: 2); // -1.6094379124341003
// Quantile function
int icdf1 = dist.InverseDistributionFunction(p: 0.17); // 2
int icdf2 = dist.InverseDistributionFunction(p: 0.46); // 4
int icdf3 = dist.InverseDistributionFunction(p: 0.87); // 6
// Hazard (failure rate) functions
double hf = dist.HazardFunction(x: 4); // 0.5
double chf = dist.CumulativeHazardFunction(x: 4); // 0.916290731874155
// String representation
string str = dist.ToString(CultureInfo.InvariantCulture); // "U(x; a = 2, b = 6)"
Assert.AreEqual(4.0, mean);
Assert.AreEqual(4.0, median);
Assert.AreEqual(1.3333333333333333, var);
Assert.AreEqual(0.916290731874155, chf, 1e-10);
Assert.AreEqual(0.2, cdf);
Assert.AreEqual(0.2, pmf1);
Assert.AreEqual(0.2, pmf2);
Assert.AreEqual(0.2, pmf3);
Assert.AreEqual(-1.6094379124341003, lpmf);
Assert.AreEqual(0.5, hf);
Assert.AreEqual(0.8, ccdf);
Assert.AreEqual(2, icdf1);
Assert.AreEqual(4, icdf2);
Assert.AreEqual(6, icdf3);
Assert.AreEqual("U(x; a = 2, b = 6)", str);
var range1 = dist.GetRange(0.95);
var range2 = dist.GetRange(0.99);
var range3 = dist.GetRange(0.01);
Assert.AreEqual(2, range1.Min);
Assert.AreEqual(6, range1.Max);
Assert.AreEqual(2.0, range2.Min);
Assert.AreEqual(6, range2.Max);
Assert.AreEqual(2.0, range3.Min);
Assert.AreEqual(6, range3.Max);
}
private static void generator9(GeneratorSeed seed)
{
//ZLOZITA OPRAVA
//diskretne rovnomerne Tmin = 120, Tmax = 260
var gen9 = new UniformDiscreteDistribution(seed.GetRandomSeed(), 120, 260);
TestDistributionsToFileInt(gen9, "generator_9_diskretne_uniform_min_120_max_260.dst");
}
public void GetRangeTest()
{
var u = new UniformDiscreteDistribution(-8, 7);
var range = u.GetRange(0.99);
Assert.AreEqual(-8, range.Min);
Assert.AreEqual(7, range.Max);
}
private static void generator7(GeneratorSeed seed)
{
///////////////////////////////////////////////////////////////////////////////////////////////
//pravdepodobnosti jednotlivych oprav a ich trvanie
// JEDNODUCHA OPRAVA
//diskretne rovnomerne = Tmin = 2, Tmax = 20
var gen7 = new UniformDiscreteDistribution(seed.GetRandomSeed(), 2, 20);
TestDistributionsToFileInt(gen7, "generator_7_diskretne_uniform_min_2_max_20.dst");
}
private static void generatorPriemerDiskretny(GeneratorSeed seed)
{
UniformDiscreteDistribution gen = new UniformDiscreteDistribution(seed.GetRandomSeed(), 0, 10);
int sucet = 0;
int count = 100000000;
for (int i = 0; i < count; i++)
{
sucet += gen.GenerateInt();
}
Console.WriteLine((double)sucet / (count));
}
public void insertion_sort_with_items_success()
{
for (int n = 1; n < 100; n += 10)
{
for (int i = 0; i < 100; i++)
{
int[] random = UniformDiscreteDistribution.Random(n);
double[] expected = random.ToDouble();
double[] a = random.ToDouble();
long[] ai = random.ToInt64();
double[] b = random.ToDouble();
long[] bi = random.ToInt64();
double[] c = random.ToDouble();
long[] ci = random.ToInt64();
double[] d = random.ToDouble();
long[] di = random.ToInt64();
double[] e = random.ToDouble();
long[] ei = random.ToInt64();
Array.Sort(expected);
Sort.Insertion(a, ai);
Sort.Insertion(b, bi, asc: false);
b = b.Reversed();
bi = bi.Reversed();
Sort.Insertion(c, ci, asc: true);
Func <double, double, int> greater = (x, y) => - x.CompareTo(y);
Sort.Insertion(d, di, comparer: greater, asc: false);
Sort.Insertion(e, ei, comparer: greater, asc: true);
e = e.Reversed();
ei = ei.Reversed();
Assert.IsTrue(a.IsSorted());
Assert.IsTrue(a.IsSorted(ComparerDirection.Ascending));
Assert.IsTrue(expected.IsEqual(a));
Assert.IsTrue(expected.IsEqual(b));
Assert.IsTrue(expected.IsEqual(c));
Assert.IsTrue(expected.IsEqual(d));
Assert.IsTrue(expected.IsEqual(e));
Assert.IsTrue(expected.IsEqual(ai));
Assert.IsTrue(expected.IsEqual(bi));
Assert.IsTrue(expected.IsEqual(ci));
Assert.IsTrue(expected.IsEqual(di));
Assert.IsTrue(expected.IsEqual(ei));
}
}
}
public void IntervalTest()
{
var target = new UniformDiscreteDistribution(-10, 10);
for (int k = -15; k < 15; k++)
{
double expected = target.ProbabilityMassFunction(k);
double a = target.DistributionFunction(k);
double b = target.DistributionFunction(k - 1);
double c = a - b;
Assert.AreEqual(expected, c, 1e-15);
Assert.AreEqual(c, target.DistributionFunction(k - 1, k), 1e-15);
}
}
public void nth_element_1()
{
for (int size = 1; size < 1000; size += 10)
{
for (int nth = 1; nth < size; nth += 10)
{
int[] random = UniformDiscreteDistribution.Random(size);
double[] a = random.ToDouble();
double[] b = random.ToDouble();
int[] bk = (int[])random.Clone();
double[] c = random.ToDouble();
double[] d = random.ToDouble();
int[] dk = (int[])random.Clone();
double[] e = random.ToDouble();
double[] f = random.ToDouble();
int[] fk = (int[])random.Clone();
Sort.NthElement(a, 0, a.Length - 1, nth);
Sort.NthElement(b, bk, 0, b.Length - 1, nth);
Assert.IsTrue(a.IsEqual(b));
Assert.IsTrue(a.IsEqual(bk));
Func <double, double, int> comparer = (x, y) => x.CompareTo(y);
Sort.NthElement(c, 0, a.Length - 1, nth, comparer);
Sort.NthElement(d, dk, 0, b.Length - 1, nth, comparer);
var str = random.ToString(CSharpArrayFormatProvider.InvariantCulture);
Assert.IsTrue(a.IsEqual(c));
Assert.IsTrue(c.IsEqual(d));
Assert.IsTrue(d.IsEqual(dk));
Func <double, double, int> comparer2 = (x, y) => - x.CompareTo(y);
Sort.NthElement(e, 0, a.Length - 1, nth, comparer2, asc: false);
Sort.NthElement(f, fk, 0, b.Length - 1, nth, comparer2, asc: false);
Assert.IsTrue(a.IsEqual(e));
Assert.IsTrue(e.IsEqual(f));
Assert.IsTrue(f.IsEqual(fk));
Assert.IsTrue(a.IsEqual(c));
Assert.IsTrue(a.IsEqual(d));
Assert.IsTrue(a.IsEqual(e));
Assert.IsTrue(a.IsEqual(f));
Assert.IsTrue(a.IsEqual(fk));
}
}
}
public void PosteriorTest1()
{
// Example from http://ai.stanford.edu/~serafim/CS262_2007/notes/lecture5.pdf
double[,] A =
{
{ 0.95, 0.05 }, // fair dice state
{ 0.05, 0.95 }, // loaded dice state
};
double[,] B =
{
{ 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0 }, // fair dice probabilities
{ 1 / 10.0, 1 / 10.0, 1 / 10.0, 1 / 10.0, 1 / 10.0, 1 / 2.0 }, // loaded probabilities
};
double[] pi = { 0.5, 0.5 };
HiddenMarkovModel hmm = new HiddenMarkovModel(A, B, pi);
int[] x = new int[] { 1, 2, 1, 5, 6, 2, 1, 5, 2, 4 }.Subtract(1);
int[] y = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
double py = Math.Exp(hmm.Evaluate(x, y));
Assert.AreEqual(0.00000000521158647211, py, 1e-16);
x = new int[] { 1, 2, 1, 5, 6, 2, 1, 5, 2, 4 }.Subtract(1);
y = new int[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
py = Math.Exp(hmm.Evaluate(x, y));
Assert.AreEqual(0.00000000015756235243, py, 1e-16);
Accord.Math.Tools.SetupGenerator(0);
var u = new UniformDiscreteDistribution(0, 6);
int[] sequence = u.Generate(1000);
int start = 120;
int end = 150;
for (int i = start; i < end; i += 2)
{
sequence[i] = 5;
}
// Predict the next observation in sequence
int[] path;
double[][] p = hmm.Posterior(sequence, out path);
for (int i = 0; i < path.Length; i++)
{
Assert.AreEqual(1, p[i][0] + p[i][1], 1e-10);
}
int loaded = 0;
for (int i = 0; i < start; i++)
{
if (p[i][1] > 0.95)
{
loaded++;
}
}
Assert.AreEqual(0, loaded);
loaded = 0;
for (int i = start; i < end; i++)
{
if (p[i][1] > 0.95)
{
loaded++;
}
}
Assert.IsTrue(loaded > 15);
loaded = 0;
for (int i = end; i < p.Length; i++)
{
if (p[i][1] > 0.95)
{
loaded++;
}
}
Assert.AreEqual(0, loaded);
}
