public void CanSampleSequence()
{
var n = new Cauchy();
var ied = n.Samples();
GC.KeepAlive(ied.Take(5).ToArray());
}
public void CanCreateCauchy(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Location);
Assert.AreEqual(scale, n.Scale);
}
public void CanCreateCauchy()
{
var n = new Cauchy();
Assert.AreEqual(0.0, n.Location);
Assert.AreEqual(1.0, n.Scale);
}
public void CanCreateCauchy([Values(0.0, 0.0, 0.0, 10.0, -5.0, 0.0)] double location, [Values(0.1, 1.0, 10.0, 11.0, 100.0, Double.PositiveInfinity)] double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Location);
Assert.AreEqual(scale, n.Scale);
}
public void FunctionTest()
{
Cauchy dense = new Cauchy(3.6);
SparseCauchy target = new SparseCauchy(3.6);
double[] sx = { 1, -0.555556, 2, +0.250000, 3, -0.864407, 4, -0.916667 };
double[] sy = { 1, -0.666667, 2, -0.166667, 3, -0.864407, 4, -0.916667 };
double[] sz = { 1, -0.944444, 3, -0.898305, 4, -0.916667 };
double[] dx = { -0.555556, +0.250000, -0.864407, -0.916667 };
double[] dy = { -0.666667, -0.166667, -0.864407, -0.916667 };
double[] dz = { -0.944444, +0.000000, -0.898305, -0.916667 };
double expected, actual;
expected = dense.Function(dx, dy);
actual = target.Function(sx, sy);
Assert.AreEqual(expected, actual);
expected = dense.Function(dx, dz);
actual = target.Function(sx, sz);
Assert.AreEqual(expected, actual);
expected = dense.Function(dy, dz);
actual = target.Function(sy, sz);
Assert.AreEqual(expected, actual);
}
public void ValidateToString()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
var n = new Cauchy(1d, 2d);
Assert.AreEqual("Cauchy(x0 = 1, γ = 2)", n.ToString());
}
/// <summary>
/// Samples from a Cauchy distribution.
/// </summary>
/// <param name="location">The distribution's location.</param>
/// <param name="scale">The distribution's scale.</param>
/// <returns>The generated sample.</returns>
public double SampleFromCauchyDistribution(double location, double scale)
{
lock (this._random)
{
var distribution = new Cauchy(location, scale, this._random);
return(distribution.Sample());
}
}
public void ValidateCumulativeDistribution(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(((1.0 / Constants.Pi) * Math.Atan((x - location) / scale)) + 0.5, n.CumulativeDistribution(x));
}
}
public void ValidateDensityLn(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(-Math.Log((Constants.Pi * scale) * (1.0 + (((x - location) / scale) * ((x - location) / scale)))), n.DensityLn(x));
}
}
public void ValidateDensity(double location, double scale)
{
var n = new Cauchy(location, scale);
for (int i = 0; i < 11; i++)
{
double x = i - 5.0;
Assert.AreEqual <double>(1.0 / (Constants.Pi * scale * (1.0 + ((x - location) / scale) * ((x - location) / scale))), n.Density(x));
}
}
public void ValidateDensityLn([Values(0.0, 0.0, 0.0, -5.0, 0.0, Double.PositiveInfinity)] double location, [Values(0.1, 1.0, 10.0, 100.0, Double.PositiveInfinity, 1.0)] double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(-Math.Log((Constants.Pi * scale) * (1.0 + (((x - location) / scale) * ((x - location) / scale)))), n.DensityLn(x));
}
}
public void ValidateCumulativeDistribution([Values(0.0, 0.0, 0.0, -5.0, 0.0)] double location, [Values(0.1, 1.0, 10.0, 100.0, Double.PositiveInfinity)] double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(((1.0 / Constants.Pi) * Math.Atan((x - location) / scale)) + 0.5, n.CumulativeDistribution(x));
}
}
public void ValidateDensity(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
double expected = 1.0 / ((Constants.Pi * scale) * (1.0 + (((x - location) / scale) * ((x - location) / scale))));
Assert.AreEqual(expected, n.Density(x));
Assert.AreEqual(expected, Cauchy.PDF(location, scale, x));
}
}
public void ValidateInverseCumulativeDistribution(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
double expected = (Math.Atan((x - location) / scale)) / Math.PI + 0.5;
Assert.AreEqual(x, n.InverseCumulativeDistribution(expected), 1e-12);
Assert.AreEqual(x, Cauchy.InvCDF(location, scale, expected), 1e-12);
}
}
public static void cauchy_cdf_values_test( )
//****************************************************************************80
//
// Purpose:
//
// CAUCHY_CDF_VALUES_TEST tests CAUCHY_CDF_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 March 2007
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
double mu = 0;
double sigma = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("CAUCHY_CDF_VALUES_TEST:");
Console.WriteLine(" CAUCHY_CDF_VALUES returns values of ");
Console.WriteLine(" the Cauchy Cumulative Density Function.");
Console.WriteLine("");
Console.WriteLine(" Mu Sigma X CDF(X)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Cauchy.cauchy_cdf_values(ref n_data, ref mu, ref sigma, ref x, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ mu.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " "
+ sigma.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " "
+ fx.ToString("0.################").PadLeft(24) + "");
}
}
/// <summary>
/// Run example
/// </summary>
/// <a href="http://en.wikipedia.org/wiki/Cauchy_distribution">Cauchy distribution</a>
public void Run()
{
// 1. Initialize the new instance of the Cauchy distribution class with parameters Location = 1 and Scale = 2.
var cauchy = new Cauchy(1, 2);
Console.WriteLine(@"1. Initialize the new instance of the Cauchy distribution class with parameters Location = {0} and Scale = {1}", cauchy.Location, cauchy.Scale);
Console.WriteLine();
// 2. Distributuion properties:
Console.WriteLine(@"2. {0} distributuion properties:", cauchy);
// Cumulative distribution function
Console.WriteLine(@"{0} - Сumulative distribution at location '0.3'", cauchy.CumulativeDistribution(0.3).ToString(" #0.00000;-#0.00000"));
// Probability density
Console.WriteLine(@"{0} - Probability density at location '0.3'", cauchy.Density(0.3).ToString(" #0.00000;-#0.00000"));
// Log probability density
Console.WriteLine(@"{0} - Log probability density at location '0.3'", cauchy.DensityLn(0.3).ToString(" #0.00000;-#0.00000"));
// Entropy
Console.WriteLine(@"{0} - Entropy", cauchy.Entropy.ToString(" #0.00000;-#0.00000"));
// Largest element in the domain
Console.WriteLine(@"{0} - Largest element in the domain", cauchy.Maximum.ToString(" #0.00000;-#0.00000"));
// Smallest element in the domain
Console.WriteLine(@"{0} - Smallest element in the domain", cauchy.Minimum.ToString(" #0.00000;-#0.00000"));
// Median
Console.WriteLine(@"{0} - Median", cauchy.Median.ToString(" #0.00000;-#0.00000"));
// Mode
Console.WriteLine(@"{0} - Mode", cauchy.Mode.ToString(" #0.00000;-#0.00000"));
// 3. Generate 10 samples of the Cauchy distribution
Console.WriteLine(@"3. Generate 10 samples of the Cauchy distribution");
for (var i = 0; i < 10; i++)
{
Console.Write(cauchy.Sample().ToString("N05") + @" ");
}
Console.WriteLine();
}
public void ValidateToString()
{
var n = new Cauchy(1.0, 2.0);
Assert.AreEqual("Cauchy(Location = 1, Scale = 2)", n.ToString());
}
public void CanSample()
{
var n = new Cauchy();
n.Sample();
}
public void CanSampleSequence()
{
var n = new Cauchy();
var ied = n.Samples();
ied.Take(5).ToArray();
}
public void ValidateToString()
{
var n = new Cauchy(1.0, 2.0);
Assert.AreEqual("Cauchy(Location = 1, Scale = 2)", n.ToString());
}
public void SetBadScaleFail()
{
var n = new Cauchy();
Assert.Throws <ArgumentOutOfRangeException>(() => n.Scale = -1.0);
}
public void SetScaleFail()
{
var n = new Cauchy();
n.Scale = -1.0;
}
public void SetBadScaleFail()
{
var n = new Cauchy();
Assert.That(() => n.Scale = -1.0, Throws.ArgumentException);
}
public void SetBadLocationFail()
{
var n = new Cauchy();
Assert.Throws <ArgumentOutOfRangeException>(() => n.Location = Double.NaN);
}
public void SetBadLocationFail()
{
var n = new Cauchy();
Assert.That(() => n.Location = Double.NaN, Throws.ArgumentException);
}
public void CanSetScale(double scale)
{
var n = new Cauchy();
n.Scale = scale;
}
public void CanSetLocation(double location)
{
var n = new Cauchy();
n.Location = location;
}
public void ValidateSkewness(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual<double>(0.0, n.Skewness);
}
public void ValidateEntropy(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Math.Log(4.0 * Constants.Pi * scale), n.Entropy);
}
public void ValidateDensityLn([Values(0.0, 0.0, 0.0, -5.0, 0.0, Double.PositiveInfinity)] double location, [Values(0.1, 1.0, 10.0, 100.0, Double.PositiveInfinity, 1.0)] double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(-Math.Log((Constants.Pi * scale) * (1.0 + (((x - location) / scale) * ((x - location) / scale)))), n.DensityLn(x));
}
}
public void ValidateMedian(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Median);
}
public void CanCreateCauchy()
{
var n = new Cauchy();
Assert.AreEqual(0.0, n.Location);
Assert.AreEqual(1.0, n.Scale);
}
public void ValidateMaximum(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Double.PositiveInfinity, n.Maximum);
}
public void ValidateMinimum(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual<double>(Double.NegativeInfinity, n.Minimum);
}
public void ValidateDensityLn(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(-Math.Log((Constants.Pi * scale) * (1.0 + (((x - location) / scale) * ((x - location) / scale)))), n.DensityLn(x));
}
}
public void SetLocationFail()
{
var n = new Cauchy();
n.Location = Double.NaN;
}
public void ValidateCumulativeDistribution(double location, double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(((1.0 / Constants.Pi) * Math.Atan((x - location) / scale)) + 0.5, n.CumulativeDistribution(x));
}
}
public void CauchyCreateFailsWithBadParameters(double location, double scale)
{
var n = new Cauchy(location, scale);
}
public void CanCreateCauchy(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Location);
Assert.AreEqual(scale, n.Scale);
}
public void ValidateToString()
{
var n = new Cauchy(1d, 2d);
Assert.AreEqual("Cauchy(x0 = 1, γ = 2)", n.ToString());
}
public void SetBadScaleFail()
{
var n = new Cauchy();
Assert.Throws<ArgumentOutOfRangeException>(() => n.Scale = -1.0);
}
public void Test_Randomized_Data()
{
#region Data Generators...
Random rnd = null; // initialized later
var dfFlips = new Cauchy(10, 4, rnd);
Func <int> makeFlips = () =>
{
int x = 0;
while (x <= 0 || x >= 30)
{
x = (int)Math.Floor(dfFlips.Sample());
}
return(x);
};
var dfElev = new Cauchy(10, 1, rnd);
Func <double> makeElevation = () =>
{
double x = 0;
while (x <= 0.0 || x >= 30)
{
x = dfElev.Sample();
}
return(x);
};
bool flipFlop = false;
Func <bool> makeFlipFlop = () =>
{
if (rnd.NextDouble() < 0.01)
{
flipFlop = !flipFlop;
}
return(flipFlop);
};
var cities = new[]
{
"Paris", "Marseilles", "Lyon", "Toulouse", "Nice",
"Nantes", "Strasbourg", "Montpellier", "Bordeaux", "Lille",
"Rennes", "Reims", "Le Havre", "Saint-Étienne", "Toulon",
"Grenoble", "Dijon", "Angers", "Saint-Denis", "Villeurbanne",
"Nîmes", "Le Mans", "Clermont-Ferrand", "Aix-en-Provence", "Brest"
};
var dfLoc = new Cauchy(0, 1.25, rnd);
Func <string> makeLocation = () =>
{
int x = cities.Length;
while (x >= cities.Length)
{
x = (int)Math.Floor(Math.Abs(dfLoc.Sample()));
}
return(cities[x]);
};
Func <int> makeHeadsOrTails = () => rnd.NextDouble() < 0.01 ? CoinToss.EDGE : rnd.NextDouble() <= 0.5 ? CoinToss.HEAD : CoinToss.TAIL; // biased!
Func <bool> makeValid = () => rnd.Next(1000) != 666;
#endregion
//foreach (var N in new[] { 1000, 2000, 5000, 10 * 1000, 20 * 1000, 50 * 1000, 100 * 1000 })
const int N = 10 * 1000;
{
Console.WriteLine("=================================================================================================================================================================================================================================");
Console.WriteLine("N = {0:N0}", N);
Console.WriteLine("=================================================================================================================================================================================================================================");
rnd = new Random(123456);
var dataSet = Enumerable
.Range(0, N)
.Select(i => new KeyValuePair <int, CoinToss>(i, new CoinToss
{
Id = Guid.NewGuid(),
Valid = makeValid(),
Result = makeHeadsOrTails(),
Flips = makeFlips(),
Elevation = makeElevation(),
Location = makeLocation(),
Daytime = makeFlipFlop(),
}))
.ToList();
var indexLoc = new MemoryIndex <string>(StringComparer.Ordinal);
var indexValid = new MemoryIndex <bool>();
var indexResult = new MemoryIndex <int>();
var indexFlips = new MemoryIndex <int>();
var indexElevation = new MemoryIndex <double>(); // quantized!
var indexFlipFlop = new MemoryIndex <bool>();
var inserters = new []
{
MakeInserter <KeyValuePair <int, CoinToss>, int>(indexResult, (kv) => kv.Key, (kv) => kv.Value.Result),
MakeInserter <KeyValuePair <int, CoinToss>, bool>(indexValid, (kv) => kv.Key, (kv) => kv.Value.Valid),
MakeInserter <KeyValuePair <int, CoinToss>, bool>(indexFlipFlop, (kv) => kv.Key, (kv) => kv.Value.Daytime),
MakeInserter <KeyValuePair <int, CoinToss>, int>(indexFlips, (kv) => kv.Key, (kv) => kv.Value.Flips),
MakeInserter <KeyValuePair <int, CoinToss>, double>(indexElevation, (kv) => kv.Key, (kv) => Math.Round(kv.Value.Elevation, 1, MidpointRounding.AwayFromZero)),
MakeInserter <KeyValuePair <int, CoinToss>, string>(indexLoc, (kv) => kv.Key, (kv) => kv.Value.Location),
};
var database = new Dictionary <int, CoinToss>();
//Console.Write("Inserting data: ...");
foreach (var data in dataSet)
{
//if (database.Count % 1000 == 0) Console.Write("\rInserting data: {0} / {1}", database.Count, N);
database[data.Key] = data.Value;
foreach (var inserter in inserters)
{
inserter(data);
}
}
//Console.WriteLine("\rInserting data: {0} / {1}", database.Count, N);
Console.WriteLine();
DumpIndex("Result", indexResult, (s, _) => s, heatMaps: true);
Console.WriteLine();
DumpIndex("Valid", indexValid, (s, _) => s, heatMaps: true);
Console.WriteLine();
DumpIndex("FlipFlops", indexFlipFlop, (s, _) => s, heatMaps: true);
Console.WriteLine();
DumpIndex("Flips", indexFlips, (s, _) => s, heatMaps: true);
Console.WriteLine();
DumpIndex("Location", indexLoc, (_, n) => - n, heatMaps: true);
Console.WriteLine();
DumpIndex("Elevation", indexElevation, (s, _) => s, heatMaps: true);
//Console.WriteLine(indexValid.Values[true].Dump());
//Console.WriteLine(indexValid.Values[true].ToSlice().ToHexaString());
Console.WriteLine();
Console.WriteLine();
}
}
public void ValidateSkewnessThrowsNotSupportedException()
{
var n = new Cauchy(-0.0, 2.0);
Assert.Throws<NotSupportedException>(() => { var s = n.Skewness; });
}
public void SetBadLocationFail()
{
var n = new Cauchy();
Assert.Throws<ArgumentOutOfRangeException>(() => n.Location = Double.NaN);
}
public void ValidateMode(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual<double>(location, n.Mode);
}
public void ValidateEntropy([Values(-0.0, 0.0, 0.1, 1.0, 10.0)] double location, [Values(2.0, 2.0, 4.0, 10.0, 11.0)] double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Math.Log(4.0 * Constants.Pi * scale), n.Entropy);
}
private static void cauchy_cdf_test()
//****************************************************************************80
//
// Purpose:
//
// CAUCHY_CDF_TEST tests CAUCHY_CDF, CAUCHY_CDF_INV, CAUCHY_PDF;
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 August 2006
//
// Author:
//
// John Burkardt
//
{
int i;
int seed = 123456789;
Console.WriteLine("");
Console.WriteLine("CAUCHY_CDF_TEST");
Console.WriteLine(" CAUCHY_CDF evaluates the Cauchy CDF;");
Console.WriteLine(" CAUCHY_CDF_INV inverts the Cauchy CDF.");
Console.WriteLine(" CAUCHY_PDF evaluates the Cauchy PDF;");
const double a = 2.0;
const double b = 3.0;
Console.WriteLine("");
Console.WriteLine(" PDF parameter A = " + a + "");
Console.WriteLine(" PDF parameter B = " + b + "");
if (!Cauchy.cauchy_check(a, b))
{
Console.WriteLine("");
Console.WriteLine("CAUCHY_CDF_TEST - Fatal error!");
Console.WriteLine(" The parameters are not legal.");
return;
}
Console.WriteLine("");
Console.WriteLine(" X PDF CDF CDF_INV");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
double x = Cauchy.cauchy_sample(a, b, ref seed);
double pdf = Cauchy.cauchy_pdf(x, a, b);
double cdf = Cauchy.cauchy_cdf(x, a, b);
double x2 = Cauchy.cauchy_cdf_inv(cdf, a, b);
Console.WriteLine(" "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ pdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ cdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ x2.ToString(CultureInfo.InvariantCulture).PadLeft(12) + "");
}
}
public void ValidateMaximum([Values(-0.0, 0.0, 0.1, 1.0, 10.0, 0.0)] double location, [Values(2.0, 2.0, 4.0, 10.0, 11.0, Double.PositiveInfinity)] double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Double.PositiveInfinity, n.Maximum);
}
public void ValidateEntropy(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Math.Log(4.0 * Constants.Pi * scale), n.Entropy);
}
public void CanSample()
{
var n = new Cauchy();
n.Sample();
}
public void ValidateSkewnessThrowsNotSupportedException()
{
var n = new Cauchy(-0.0, 2.0);
Assert.Throws <NotSupportedException>(() => { var s = n.Skewness; });
}
public void ValidateCumulativeDistribution([Values(0.0, 0.0, 0.0, -5.0, 0.0)] double location, [Values(0.1, 1.0, 10.0, 100.0, Double.PositiveInfinity)] double scale)
{
var n = new Cauchy(location, scale);
for (var i = 0; i < 11; i++)
{
var x = i - 5.0;
Assert.AreEqual(((1.0 / Constants.Pi) * Math.Atan((x - location) / scale)) + 0.5, n.CumulativeDistribution(x));
}
}
public void ValidateMedian(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Median);
}
public void CanCreateCauchy([Values(0.0, 0.0, 0.0, 10.0, -5.0, 0.0)] double location, [Values(0.1, 1.0, 10.0, 11.0, 100.0, Double.PositiveInfinity)] double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(location, n.Location);
Assert.AreEqual(scale, n.Scale);
}
public void ValidateMaximum(double location, double scale)
{
var n = new Cauchy(location, scale);
Assert.AreEqual(Double.PositiveInfinity, n.Maximum);
}
private static void cauchy_sample_test()
//****************************************************************************80
//
// Purpose:
//
// CAUCHY_SAMPLE_TEST tests CAUCHY_MEAN, CAUCHY_SAMPLE, CAUCHY_VARIANCE;
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 August 2006
//
// Author:
//
// John Burkardt
//
{
const int SAMPLE_NUM = 1000;
int i;
int seed = 123456789;
double[] x = new double [SAMPLE_NUM];
Console.WriteLine("");
Console.WriteLine("CAUCHY_SAMPLE_TEST");
Console.WriteLine(" CAUCHY_MEAN computes the Cauchy mean;");
Console.WriteLine(" CAUCHY_SAMPLE samples the Cauchy distribution;");
Console.WriteLine(" CAUCHY_VARIANCE computes the Cauchy variance;");
const double a = 2.0;
const double b = 3.0;
Console.WriteLine("");
Console.WriteLine(" PDF parameter A = " + a + "");
Console.WriteLine(" PDF parameter B = " + b + "");
if (!Cauchy.cauchy_check(a, b))
{
Console.WriteLine("");
Console.WriteLine("CAUCHY_SAMPLE_TEST - Fatal error!");
Console.WriteLine(" The parameters are not legal.");
return;
}
double mean = Cauchy.cauchy_mean(a, b);
double variance = Cauchy.cauchy_variance(a, b);
Console.WriteLine("");
Console.WriteLine(" PDF mean = " + mean + "");
Console.WriteLine(" PDF variance = " + variance + "");
for (i = 0; i < SAMPLE_NUM; i++)
{
x[i] = Cauchy.cauchy_sample(a, b, ref seed);
}
mean = typeMethods.r8vec_mean(SAMPLE_NUM, x);
variance = typeMethods.r8vec_variance(SAMPLE_NUM, x);
double xmax = typeMethods.r8vec_max(SAMPLE_NUM, x);
double xmin = typeMethods.r8vec_min(SAMPLE_NUM, x);
Console.WriteLine("");
Console.WriteLine(" Sample size = " + SAMPLE_NUM + "");
Console.WriteLine(" Sample mean = " + mean + "");
Console.WriteLine(" Sample variance = " + variance + "");
Console.WriteLine(" Sample maximum = " + xmax + "");
Console.WriteLine(" Sample minimum = " + xmin + "");
}
public void ValidateDensity(double location, double scale)
{
var n = new Cauchy(location, scale);
for (int i = 0; i < 11; i++)
{
double x = i - 5.0;
Assert.AreEqual<double>(1.0 / (Constants.Pi * scale * (1.0 + ((x - location) / scale) * ((x - location) / scale))), n.Density(x));
}
}
