/// <summary>
/// Tests that the
/// <see cref="O:Novacta.Analytics.ProbabilityDistribution.
/// Sample"/>
/// method fails when parameter sampleSize is not positive.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void SampleSizeIsNotPositive(
TestableProbabilityDistribution testableDistribution)
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_POSITIVE" });
string parameterName = "sampleSize";
// distribution.Sample(sampleSize)
ArgumentExceptionAssert.Throw(
() =>
{
var values = testableDistribution.Distribution.Sample(
sampleSize: 0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
// distribution.Sample(sampleSize, destinationArray, destinationIndex)
ArgumentExceptionAssert.Throw(
() =>
{
testableDistribution.Distribution.Sample(
sampleSize: 0,
destinationArray: new double[1],
destinationIndex: 0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
/// <summary>
/// Tests that the
/// <see cref="ProbabilityDistribution.
/// Sample(int, double[], int)"/>
/// method fails when parameter sampleSize is too big to
/// fit in the destination array.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void SampleSizeIsTooBig(
TestableProbabilityDistribution testableDistribution)
{
string STR_EXCEPT_PDF_SAMPLESIZE_ARRAYLENGTH_MISMATCH =
String.Format(
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PDF_SAMPLESIZE_ARRAYLENGTH_MISMATCH" }),
"sampleSize",
"destinationArray",
"destinationIndex");
string parameterName = "sampleSize";
ArgumentExceptionAssert.Throw(
() =>
{
testableDistribution.Distribution.Sample(
sampleSize: 2,
destinationArray: new double[1],
destinationIndex: 0);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PDF_SAMPLESIZE_ARRAYLENGTH_MISMATCH,
expectedParameterName: parameterName);
}
/// <summary>
/// Provides methods to test that the
/// <see cref="O:Novacta.Analytics.ProbabilityDistribution.
/// InverseCdf"/>
/// method fails when parameter arguments is <b>null</b>.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void ArgumentsIsNull(
TestableProbabilityDistribution testableDistribution)
{
string parameterName = "arguments";
// DoubleMatrix
ArgumentExceptionAssert.Throw(
() =>
{
var values = testableDistribution.Distribution.InverseCdf(
arguments: (DoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
// ReadOnlyDoubleMatrix
ArgumentExceptionAssert.Throw(
() =>
{
var values = testableDistribution.Distribution.InverseCdf(
arguments: (ReadOnlyDoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
/// <summary>
/// Provides methods to test that the
/// <see cref="O:Novacta.Analytics.ProbabilityDistribution.
/// InverseCdf"/>
/// method fails when the CDF cannot be inverted.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void CdfCannotBeInverted(
TestableProbabilityDistribution testableDistribution)
{
string STR_EXCEPT_PDF_INVERSE_CDF_NOT_SUPPORTED =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PDF_INVERSE_CDF_NOT_SUPPORTED" });
// DoubleMatrix
ExceptionAssert.Throw(
() =>
{
var values = testableDistribution.Distribution.InverseCdf(
arguments: DoubleMatrix.Identity(2));
},
expectedType: typeof(NotSupportedException),
expectedMessage: STR_EXCEPT_PDF_INVERSE_CDF_NOT_SUPPORTED);
// ReadOnlyDoubleMatrix
ExceptionAssert.Throw(
() =>
{
var values = testableDistribution.Distribution.InverseCdf(
arguments: DoubleMatrix.Identity(2).AsReadOnly());
},
expectedType: typeof(NotSupportedException),
expectedMessage: STR_EXCEPT_PDF_INVERSE_CDF_NOT_SUPPORTED);
}
/// <summary>
/// Tests that the
/// <see cref="ProbabilityDistribution.
/// CanInvertCdf"/>
/// property terminates successfully when expected.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void Succeed(
TestableProbabilityDistribution testableDistribution)
{
Assert.AreEqual(
expected: testableDistribution.CanInvertCdf,
actual: testableDistribution.Distribution.CanInvertCdf);
}
/// <summary>
/// Tests that the
/// <see cref="ProbabilityDistribution.
/// StandardDeviation"/>
/// method terminates successfully when expected.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void Succeed(
TestableProbabilityDistribution testableDistribution)
{
Assert.AreEqual(
expected: Math.Sqrt(testableDistribution.Variance),
actual: testableDistribution.Distribution.StandardDeviation(),
delta: DoubleMatrixTest.Accuracy);
}
/// <summary>
/// Tests that the
/// <see cref="ProbabilityDistribution.
/// Variance"/>
/// method terminates successfully when expected.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void Succeed(
TestableProbabilityDistribution testableDistribution)
{
Assert.AreEqual(
expected: testableDistribution.Variance,
actual: testableDistribution.Distribution.Variance(),
delta: DoubleMatrixTest.Accuracy);
}
/// <summary>
/// Tests that the overloaded
/// <see cref="O:Novacta.Analytics.ProbabilityDistribution.
/// Cdf"/>
/// method terminates successfully when expected.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void Succeed(TestableProbabilityDistribution testableDistribution)
{
var partialGraph = testableDistribution.CdfPartialGraph;
var distribution = testableDistribution.Distribution;
CheckPartialGraph(
(Func <double, double>)distribution.Cdf,
partialGraph);
CheckPartialGraph(
(Func <DoubleMatrix, DoubleMatrix>)distribution.Cdf,
partialGraph);
CheckPartialGraph(
(Func <ReadOnlyDoubleMatrix, DoubleMatrix>)distribution.Cdf,
partialGraph);
}
/// <summary>
/// Tests that the
/// <see cref="ProbabilityDistribution.
/// Sample(int, double[], int)"/>
/// method fails when parameter destinationArray is <b>null</b>.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
public static void DestinationArrayIsNull(
TestableProbabilityDistribution testableDistribution)
{
string parameterName = "destinationArray";
ArgumentExceptionAssert.Throw(
() =>
{
testableDistribution.Distribution.Sample(
sampleSize: 1,
destinationArray: null,
destinationIndex: 0);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
/// <summary>
/// Tests that the overloaded
/// <see cref="O:Novacta.Analytics.ProbabilityDistribution.
/// Sample"/>
/// method terminates successfully when expected.
/// </summary>
/// <param name="testableDistribution">
/// The testable probability distribution providing the instance
/// on which to invoke the methods to test and their expected
/// behaviors.
/// </param>
/// <param name="sampleSize">The sample size.</param>
/// <param name="delta">The required accuracy.</param>
public static void Succeed(
TestableProbabilityDistribution testableDistribution,
int sampleSize,
double delta)
{
var distribution = testableDistribution.Distribution;
bool CanCheckChebyshevInequality =
!Double.IsInfinity(distribution.Mean())
&&
!Double.IsPositiveInfinity(distribution.Variance());
// distribution.Sample()
{
var sample = DoubleMatrix.Dense(sampleSize, 1);
for (int i = 0; i < sampleSize; i++)
{
sample[i] = distribution.Sample();
}
if (CanCheckChebyshevInequality)
{
CheckChebyshevInequality(
distribution: distribution,
sampleMean: Stat.Mean(sample),
sampleSize: sampleSize,
delta: delta);
}
}
// distribution.Sample(sampleSize)
{
var sample = distribution.Sample(sampleSize);
Assert.AreEqual(expected: sampleSize, actual: sample.Count);
Assert.AreEqual(expected: true, sample.IsColumnVector);
if (CanCheckChebyshevInequality)
{
CheckChebyshevInequality(
distribution: distribution,
sampleMean: Stat.Mean(sample),
sampleSize: sampleSize,
delta: delta);
}
}
// distribution.Sample(sampleSize, destinationArray, destinationIndex)
{
int destinationSize = sampleSize * 10;
int partialSize = sampleSize;
var sample = DoubleMatrix.Dense(destinationSize, 1);
double[] destinationArray = sample.GetStorage();
IndexCollection destinationIndexes =
IndexCollection.Sequence(0, partialSize, destinationSize - 1);
foreach (var destinationIndex in destinationIndexes)
{
distribution.Sample(partialSize, destinationArray, destinationIndex);
}
if (CanCheckChebyshevInequality)
{
CheckChebyshevInequality(
distribution: distribution,
sampleMean: Stat.Mean(sample),
sampleSize: sampleSize,
delta: delta);
}
}
}
