public void ConstructorTest()
{
// Valid input
{
var indexes = IndexCollection.Default(lastIndex: 5);
var randomIndexPermutation = new
RandomIndexPermutation(indexes: indexes);
int i = 0;
foreach (var index in randomIndexPermutation.Indexes)
{
Assert.AreEqual(
expected: indexes[i],
actual: index);
i++;
}
}
// indexes is null
{
IndexCollection indexes = null;
ArgumentExceptionAssert.Throw(
() =>
{
new RandomIndexPermutation(
indexes: indexes);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "indexes");
}
}
public void StandardTest()
{
// dimension is not positive
{
ArgumentExceptionAssert.Throw(
() =>
{
var basis = Basis.Standard(0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE"),
expectedParameterName: "dimension");
}
// dimension is valid
{
var basis = Basis.Standard(2);
var actual = basis.GetBasisMatrix();
var expected = DoubleMatrix.Identity(2);
DoubleMatrixAssert.AreEqual(
expected,
actual,
DoubleMatrixTest.Accuracy);
}
}
public void CompleteDiameterTest()
{
// cluster is null
{
ArgumentExceptionAssert.Throw(
() =>
{
var partition = Distance.CompleteDiameter((DoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "cluster");
}
// cluster is valid
{
var items = IndexCollection.Range(0, 3);
int numberOfItems = items.Count;
var attributes = IrisDataSet.GetAttributesAsDoubleMatrix()[items, ":"];
var actual = Distance.CompleteDiameter(attributes);
var expected = 0.6480741;
Assert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy);
}
}
public void AnalyzeTest()
{
// dataSet is null
{
string parameterName = "dataSet";
ArgumentExceptionAssert.Throw(
() =>
{
MultipleCorrespondence.Analyze(
null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// dataSet must have positive marginal column sums
{
var STR_EXCEPT_GDA_MCA_NON_POSITIVE_MARGINAL_SUMS =
ImplementationServices.GetResourceString(
"STR_EXCEPT_GDA_MCA_NON_POSITIVE_MARGINAL_SUMS");
string parameterName = "dataSet";
CategoricalVariable color = new("COLOR")
{
{ 0, "Red" },
public void SetRandomNumberGeneratorTest()
{
// Valid input
{
var distribution = GaussianDistribution.Standard();
distribution.RandomNumberGenerator =
RandomNumberGenerator.CreateNextMT2203(77777);
int sampleSize = 10000;
var sample = distribution.Sample(sampleSize);
RandomNumberGeneratorTest.CheckChebyshevInequality(
distributionMean: 0.0,
distributionVariance: 1.0,
sampleMean: Stat.Mean(sample),
sampleSize: sampleSize,
delta: .01);
}
// value is null
{
ArgumentExceptionAssert.Throw(
() =>
{
GaussianDistribution.Standard()
.RandomNumberGenerator = null;
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "value");
}
}
public void SigmaTest()
{
// Valid sigma
{
var distribution = GaussianDistribution.Standard();
var expected = 1.123;
distribution.Sigma = expected;
Assert.AreEqual(
expected: expected,
actual: distribution.Sigma,
delta: DoubleMatrixTest.Accuracy);
}
// Non positive sigma
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_POSITIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
GaussianDistribution.Standard().Sigma = 0.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "value");
}
}
public void ConstructorTest()
{
// Valid input
{
var lowerBound = -1.1;
var upperBound = 2.2;
var distribution = new UniformDistribution(
lowerBound: lowerBound,
upperBound: upperBound);
Assert.AreEqual(
expected: lowerBound,
actual: distribution.LowerBound,
delta: DoubleMatrixTest.Accuracy);
Assert.AreEqual(
expected: upperBound,
actual: distribution.UpperBound,
delta: DoubleMatrixTest.Accuracy);
}
// upperBound == lowerBound
{
string STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER"),
"upperBound",
"lowerBound");
ArgumentExceptionAssert.Throw(
() =>
{
new UniformDistribution(lowerBound: 1.0, upperBound: 1.0);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER,
expectedParameterName: "upperBound");
}
// upperBound < lowerBound
{
string STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER"),
"upperBound",
"lowerBound");
ArgumentExceptionAssert.Throw(
() =>
{
new UniformDistribution(lowerBound: 2.0, upperBound: 1.0);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER,
expectedParameterName: "upperBound");
}
}
public void ParametricHessianTest()
{
// function is null
{
string parameterName = "function";
ArgumentExceptionAssert.Throw(
() =>
{
NumericalDifferentiation.Hessian(
function: null,
argument: EngineFailureModel.EstimatedParameters,
parameter: EngineFailureModel.Data);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// argument is null
{
string parameterName = "argument";
ArgumentExceptionAssert.Throw(
() =>
{
NumericalDifferentiation.Hessian(
function: EngineFailureModel.LogLikelihood,
argument: null,
parameter: EngineFailureModel.Data);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// valid input
{
var expected =
EngineFailureModel.LogLikelihoodHessian(
argument: EngineFailureModel.EstimatedParameters,
parameter: EngineFailureModel.Data);
var actual =
NumericalDifferentiation.Hessian(
function: EngineFailureModel.LogLikelihood,
argument: EngineFailureModel.EstimatedParameters,
parameter: EngineFailureModel.Data);
DoubleMatrixAssert.AreEqual(
expected: expected,
actual: actual,
delta: DoubleMatrixTest.Accuracy);
}
}
public void FactorialTest()
{
// n is negative
{
string STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.Factorial(n: -1);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE,
expectedParameterName: "n");
}
// valid input
{
var x = new int[]
{
0,
1,
2,
3,
10,
1000
};
var expected = new double[]
{
1.0,
1.0,
2.0,
6.0,
3628800.0,
Double.PositiveInfinity
};
var actual = new double[6];
for (int i = 0; i < x.Length; i++)
{
actual[i] =
SpecialFunctions.Factorial(x[i]);
}
DoubleArrayAssert.AreEqual(
expected: expected,
actual: actual,
delta: 1e-8);
}
}
public void CtorTest()
{
// Wrong code base
{
string expectedPartialMessage =
RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
?
"The specified directory does not exist or an error occurred when " +
"trying to determine if the specified folder exists. "
:
"The specified directory does not exist or an error occurred when " +
"trying to determine if the specified folder exists.";
ArgumentExceptionAssert.IsThrown(
() =>
{
string codeBase = Path.Combine(Environment.CurrentDirectory,
"1a793a0c-1178-42e3-a6bc-c23ca6d7289d");
string defaultNamespace = "SampleClassLibrary.CodeExamples";
var analyzer = new CodeExamplesAnalyzer(
codeBase,
defaultNamespace);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage:
"The specified directory does not exist or an error occurred when " +
"trying to determine if the specified folder exists. ",
expectedParameterName: "codeBase");
}
// Null default namespace
{
ArgumentExceptionAssert.IsThrown(
() =>
{
string codeBase = Environment.CurrentDirectory;
string defaultNamespace = null;
var analyzer = new CodeExamplesAnalyzer(
codeBase,
defaultNamespace);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "defaultNamespace");
}
// Mainstream use case
{
string codeBase = Environment.CurrentDirectory;
string defaultNamespace = "SampleClassLibrary.CodeExamples";
var analyzer = new CodeExamplesAnalyzer(
codeBase,
defaultNamespace);
Assert.AreEqual(expected: codeBase, actual: analyzer.CodeBase);
Assert.AreEqual(expected: defaultNamespace, actual: analyzer.DefaultNamespace);
}
}
public void SuccessProbabilityTest()
{
// Valid successProbability
{
var distribution = BernoulliDistribution.Balanced();
var expected = 0.12;
distribution.SuccessProbability = expected;
Assert.AreEqual(
expected: expected,
actual: distribution.SuccessProbability,
delta: DoubleMatrixTest.Accuracy);
}
// successProbability < 0
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
BernoulliDistribution.Balanced().SuccessProbability = -2.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "value");
}
// successProbability > 1
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
BernoulliDistribution.Balanced().SuccessProbability = 2.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "value");
}
}
public void ConstructorTest()
{
// Valid input
{
var successProbability = 0.18;
var distribution = new BernoulliDistribution(
successProbability: successProbability);
Assert.AreEqual(
expected: successProbability,
actual: distribution.SuccessProbability,
delta: DoubleMatrixTest.Accuracy);
}
// successProbability < 0
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
new BernoulliDistribution(successProbability: -2.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "successProbability");
}
// successProbability > 1
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
new BernoulliDistribution(successProbability: 2.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "successProbability");
}
}
public void RateTest()
{
// Valid input
{
var distribution = new ExponentialDistribution(
rate: 1.0);
var rate = 2.0;
distribution.Rate = rate;
Assert.AreEqual(
expected: rate,
actual: distribution.Rate,
delta: DoubleMatrixTest.Accuracy);
}
// value == 0
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
ArgumentExceptionAssert.Throw(
() =>
{
new ExponentialDistribution(rate: 1.0).Rate = 0.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "value");
}
// value < 0
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
ArgumentExceptionAssert.Throw(
() =>
{
new ExponentialDistribution(rate: 1.0).Rate = -1.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "value");
}
}
public void ConstructorTest()
{
// Valid input
{
var mu = -1.1;
var sigma = 2.2;
var xi = -3.3;
var distribution = new GeneralizedParetoDistribution(
mu: mu,
sigma: sigma,
xi: xi);
Assert.AreEqual(
expected: mu,
actual: distribution.Mu,
delta: DoubleMatrixTest.Accuracy);
Assert.AreEqual(
expected: sigma,
actual: distribution.Sigma,
delta: DoubleMatrixTest.Accuracy);
Assert.AreEqual(
expected: xi,
actual: distribution.Xi,
delta: DoubleMatrixTest.Accuracy);
}
// Non positive sigma
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_POSITIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
new GeneralizedParetoDistribution(
mu: 1.0, sigma: 0.0, xi: -1.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "sigma");
}
}
public void ConstructorTest()
{
// name is null
{
ArgumentExceptionAssert.Throw(
() => { new CategoricalVariable(null); },
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "name");
}
// name is white space
{
ArgumentExceptionAssert.Throw(
() => { new CategoricalVariable(" "); },
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
expectedParameterName: "name");
}
// name is empty
{
ArgumentExceptionAssert.Throw(
() => { new CategoricalVariable(string.Empty); },
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
expectedParameterName: "name");
}
// Valid name
{
string expectedName = "The name";
var target = new CategoricalVariable(expectedName);
CategoricalVariableAssert.IsStateAsExpected(
target,
expectedName,
expectedCategories: new List <Category>(),
expectedReadOnlyFlag: false);
}
}
public void StopExecutionTest()
{
// levels is null
{
string parameterName = "levels";
var context =
TestableSystemPerformanceOptimizationContext02.Get().Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.StopExecution(
iteration: 1,
levels: null,
parameters: new LinkedList <DoubleMatrix>());
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// parameters is null
{
string parameterName = "parameters";
var context =
TestableSystemPerformanceOptimizationContext02.Get().Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.StopExecution(
iteration: 1,
levels: new LinkedList <double>(),
parameters: null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
}
public void RebaseTest()
{
// newBasis is null
{
var cloud = TestableCloud00.Get().Cloud;
string parameterName = "newBasis";
ArgumentExceptionAssert.Throw(
() =>
{
cloud.Rebase(null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// newBasis must have the same dimension of this instance
{
var STR_EXCEPT_PAR_BASES_MUST_SHARE_DIMENSION =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_BASES_MUST_SHARE_DIMENSION");
var cloud = TestableCloud00.Get().Cloud;
string parameterName = "newBasis";
ArgumentExceptionAssert.Throw(
() =>
{
cloud.Rebase(Basis.Standard(cloud.Coordinates.NumberOfColumns + 1));
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_BASES_MUST_SHARE_DIMENSION,
expectedParameterName: parameterName);
}
CloudTest.Rebase.Succeed(
TestableCloud00.Get());
}
public void SmoothParameterTest()
{
// parameters is null
{
string parameterName = "parameters";
var context =
TestableSystemPerformanceOptimizationContext02.Get().Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.SmoothParameter(
parameters: null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
}
public void SampleGenerationParallelOptionsTest()
{
// value is null
{
string parameterName = "value";
var estimator = new RareEventProbabilityEstimator();
ArgumentExceptionAssert.Throw(
() =>
{
estimator.SampleGenerationParallelOptions
= null;
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// value is valid
{
int maxDegreeOfParallelism = 2;
var estimator = new RareEventProbabilityEstimator
{
SampleGenerationParallelOptions
= new System.Threading.Tasks.ParallelOptions()
{
MaxDegreeOfParallelism = maxDegreeOfParallelism
}
};
Assert.AreEqual(
expected: 2,
actual: estimator
.SampleGenerationParallelOptions
.MaxDegreeOfParallelism);
}
}
public void PerformanceEvaluationParallelOptionsTest()
{
// value is null
{
string parameterName = "value";
var optimizer = new SystemPerformanceOptimizer();
ArgumentExceptionAssert.Throw(
() =>
{
optimizer.PerformanceEvaluationParallelOptions
= null;
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// value is valid
{
int maxDegreeOfParallelism = 2;
var optimizer = new SystemPerformanceOptimizer
{
PerformanceEvaluationParallelOptions
= new System.Threading.Tasks.ParallelOptions()
{
MaxDegreeOfParallelism = maxDegreeOfParallelism
}
};
Assert.AreEqual(
expected: 2,
actual: optimizer
.PerformanceEvaluationParallelOptions.MaxDegreeOfParallelism);
}
}
public void ToDoubleMatrixByMethodTest()
{
// value is null
{
CategoricalVariable target = null;
ArgumentExceptionAssert.Throw(
() => { var result = CategoricalVariable.ToDoubleMatrix(target); },
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "value");
}
// Valid input
{
string name = "The name";
var target = new CategoricalVariable(name)
{
{ 0.0, "Zero" },
{ 1.0, "One" },
{ 2.0, "Two" }
};
var expected = DoubleMatrix.Dense(3, 1,
new double[3] {
0.0, 1.0, 2.0
});
expected.Name = target.Name;
expected.SetRowName(0, "Zero");
expected.SetRowName(1, "One");
expected.SetRowName(2, "Two");
DoubleMatrix actual = CategoricalVariable.ToDoubleMatrix(target);
DoubleMatrixAssert.AreEqual(expected, actual, 1e-2);
}
}
public void EuclideanTest()
{
// cluster is null
{
ArgumentExceptionAssert.Throw(
() =>
{
var partition = Distance.Euclidean((DoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "cluster");
}
// cluster is valid
{
var items = IndexCollection.Range(0, 3);
int numberOfItems = items.Count;
var attributes = IrisDataSet.GetAttributesAsDoubleMatrix()[items, ":"];
var actual = Distance.Euclidean(attributes);
var expected = DoubleMatrix.Dense(
numberOfItems,
numberOfItems,
new double[] {
0.0000000, 0.5385165, 0.5099020, 0.6480741,
0.5385165, 0.0000000, 0.3000000, 0.3316625,
0.5099020, 0.3000000, 0.0000000, 0.2449490,
0.6480741, 0.3316625, 0.2449490, 0.0000000
},
StorageOrder.RowMajor);
DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy);
}
}
public void SetMassesTest()
{
// Valid input
{
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
var masses = DoubleMatrix.Dense(3, 2,
new double[6] {
.1, .2, .3, .2, .1, .1
});
distribution.SetMasses(masses: masses);
DoubleMatrixAssert.AreEqual(
expected: masses,
actual: (DoubleMatrix)distribution.Masses,
delta: DoubleMatrixTest.Accuracy);
}
// masses is null
{
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
ArgumentExceptionAssert.Throw(
() =>
{
distribution.SetMasses(masses: null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: "masses");
}
// The number of rows in masses is not equal to that of values
{
string STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS"),
"values");
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
var masses = DoubleMatrix.Dense(1, 2,
new double[2] {
.5, .5
});
ArgumentExceptionAssert.Throw(
() =>
{
distribution.SetMasses(masses: masses);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: "masses");
}
// The number of columns in masses is not equal to that of values
{
string STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS"),
"values");
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
var masses = DoubleMatrix.Dense(3, 1,
new double[3] {
.2, .5, .3
});
ArgumentExceptionAssert.Throw(
() =>
{
distribution.SetMasses(masses: masses);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS,
expectedParameterName: "masses");
}
// At least an entry in masses is negative
{
string STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
var masses = DoubleMatrix.Dense(3, 2,
new double[6] {
.2, .5, .3, -.1, .1, 0
});
ArgumentExceptionAssert.Throw(
() =>
{
distribution.SetMasses(masses: masses);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "masses");
}
// The sum of the masses is not 1
{
string STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1 =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1");
var values = DoubleMatrix.Dense(3, 2,
new double[6] {
1, 2, 3, 4, 5, 6
});
var distribution = FiniteDiscreteDistribution.Uniform(
values: values);
var masses = DoubleMatrix.Dense(3, 2,
new double[6] {
.2, .5, .3, .1, .1, 0
});
ArgumentExceptionAssert.Throw(
() =>
{
distribution.SetMasses(masses: masses);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1,
expectedParameterName: "masses");
}
}
public void LogGammaTest()
{
// x is zero
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_POSITIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.LogGamma(x: 0.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "x");
}
// x is negative
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_POSITIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.LogGamma(x: -1.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "x");
}
// valid input
{
var x = new double[]
{
1.0,
10.0,
100.0,
1000.0
};
var expected = new double[]
{
0.0,
12.80182748008147,
359.13420536957540,
5905.22042320918081
};
var actual = new double[4];
for (int i = 0; i < x.Length; i++)
{
actual[i] =
SpecialFunctions.LogGamma(x[i]);
}
DoubleArrayAssert.AreEqual(
expected: expected,
actual: actual,
delta: 1e-9);
}
}
public void BinomialCoefficientTest()
{
// n is negative
{
string STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.BinomialCoefficient(
n: -1,
k: 0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE,
expectedParameterName: "n");
}
// k is negative
{
string STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE =
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE" });
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.BinomialCoefficient(
n: 0,
k: -1);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_NON_NEGATIVE,
expectedParameterName: "k");
}
// n < k
{
string STR_EXCEPT_PAR_MUST_BE_NOT_GREATER_THAN_OTHER =
string.Format(
(string)Reflector.ExecuteStaticMember(
typeof(ImplementationServices),
"GetResourceString",
new string[] { "STR_EXCEPT_PAR_MUST_BE_NOT_GREATER_THAN_OTHER" }),
"k",
"n");
ArgumentExceptionAssert.Throw(
() =>
{
SpecialFunctions.BinomialCoefficient(
n: 3,
k: 4);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_NOT_GREATER_THAN_OTHER,
expectedParameterName: "k");
}
// valid input
{
var n = new int[]
{
0,
1,
2,
10,
20
};
var k = new int[]
{
0,
1,
2,
7,
8
};
var expected = new double[]
{
1.0,
1.0,
1.0,
120.0,
125970.0
};
var actual = new double[5];
for (int i = 0; i < n.Length; i++)
{
actual[i] =
SpecialFunctions.BinomialCoefficient(n[i], k[i]);
}
DoubleArrayAssert.AreEqual(
expected: expected,
actual: actual,
delta: 1e-8);
}
}
public void GetVariancesTest()
{
// supplementaryVariables is null - DoubleMatrix
{
string parameterName = "supplementaryVariables";
var cloud = TestableCloud00.Get().Cloud;
ArgumentExceptionAssert.Throw(
() =>
{
cloud.GetVariances((DoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// supplementaryVariables is null - ReadOnlyDoubleMatrix
{
string parameterName = "supplementaryVariables";
var cloud = TestableCloud00.Get().Cloud;
ArgumentExceptionAssert.Throw(
() =>
{
cloud.GetVariances((ReadOnlyDoubleMatrix)null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// supplementaryVariables must have as number of rows the number of cloud points
{
var STR_EXCEPT_PAR_ROW_DIM_MUST_MATCH_INDIVIDUALS_COUNT =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ROW_DIM_MUST_MATCH_INDIVIDUALS_COUNT");
string parameterName = "supplementaryVariables";
var cloud = TestableCloud00.Get().Cloud;
var supplementaryVariables =
DoubleMatrix.Dense(
cloud.Coordinates.NumberOfRows + 1,
10);
ArgumentExceptionAssert.Throw(
() =>
{
cloud.GetVariances(supplementaryVariables);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ROW_DIM_MUST_MATCH_INDIVIDUALS_COUNT,
expectedParameterName: parameterName);
}
// Valid input - DoubleMatrix
{
var cloud = TestableCloud00.Get().Cloud;
var actual = cloud.GetVariances((DoubleMatrix)cloud.Coordinates);
var cov_sa = cloud.Covariance;
var expected = DoubleMatrix.Dense(1, cloud.Coordinates.NumberOfColumns);
for (int i = 0; i < expected.Count; i++)
{
expected[i] = cov_sa[i, i];
}
DoubleMatrixAssert.AreEqual(
expected: expected,
actual: actual,
delta: CloudTest.Accuracy);
}
// Valid input - ReadOnlyDoubleMatrix
{
var cloud = TestableCloud00.Get().Cloud;
var actual = cloud.GetVariances(cloud.Coordinates);
var cov_sa = cloud.Covariance;
var expected = DoubleMatrix.Dense(1, cloud.Coordinates.NumberOfColumns);
for (int i = 0; i < expected.Count; i++)
{
expected[i] = cov_sa[i, i];
}
DoubleMatrixAssert.AreEqual(
expected: expected,
actual: actual,
delta: CloudTest.Accuracy);
}
}
public void ConstructorTest()
{
// coordinates is null
{
string parameterName = "coordinates";
DoubleMatrix coordinates = null;
DoubleMatrix weights = DoubleMatrix.Dense(1, 1, 1.0 / 4.0);
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// weights is null
{
string parameterName = "weights";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = null;
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// basis is null
{
string parameterName = "basis";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0);
Basis basis = null;
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// weights is not a column vector
{
var STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR");
string parameterName = "weights";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(1, 4);
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR,
expectedParameterName: parameterName);
}
// weights must have the number of rows of coordinates
{
var STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS =
string.Format(CultureInfo.InvariantCulture,
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS"),
"coordinates");
string parameterName = "weights";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(5, 1);
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
}
// weights must have non negative entries
{
var STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE");
string parameterName = "weights";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1, -1.0);
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE,
expectedParameterName: parameterName);
}
// weights must have entries summing up to 1
{
var STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1 =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1");
string parameterName = "weights";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1,
new double[4] {
.3, .6, .2, .1
});
Basis basis = Basis.Standard(2);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1,
expectedParameterName: parameterName);
}
// basis must have dimension equal to the coordinates number of columns
{
var STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS =
string.Format(CultureInfo.InvariantCulture,
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS"),
"coordinates");
string parameterName = "basis";
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0);
Basis basis = Basis.Standard(5);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: true);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis,
copyData: false);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
ArgumentExceptionAssert.Throw(
() =>
{
new Cloud(
coordinates,
weights,
basis);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS,
expectedParameterName: parameterName);
}
// Valid input and copyData is true
{
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0);
Basis basis = Basis.Standard(2);
{
var cloud = new Cloud(
coordinates,
weights,
basis,
copyData: true);
DoubleMatrixAssert.AreEqual(
expected: basis.GetBasisMatrix(),
actual: cloud.Basis.GetBasisMatrix(),
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: coordinates,
actual: cloud.Coordinates,
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: weights,
actual: cloud.Weights,
delta: CloudTest.Accuracy);
coordinates[0, 0] = Double.PositiveInfinity;
Assert.AreNotEqual(
notExpected: coordinates[0, 0],
actual: cloud.Coordinates[0, 0],
delta: CloudTest.Accuracy);
}
{
var cloud = new Cloud(
coordinates,
weights);
DoubleMatrixAssert.AreEqual(
expected: basis.GetBasisMatrix(),
actual: cloud.Basis.GetBasisMatrix(),
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: coordinates,
actual: cloud.Coordinates,
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: weights,
actual: cloud.Weights,
delta: CloudTest.Accuracy);
}
{
var cloud = new Cloud(
coordinates);
DoubleMatrixAssert.AreEqual(
expected: basis.GetBasisMatrix(),
actual: cloud.Basis.GetBasisMatrix(),
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: coordinates,
actual: cloud.Coordinates,
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: weights,
actual: cloud.Weights,
delta: CloudTest.Accuracy);
}
}
// Valid input and copyData is false
{
DoubleMatrix coordinates = DoubleMatrix.Dense(4, 2);
DoubleMatrix weights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0);
Basis basis = Basis.Standard(2);
{
var cloud = new Cloud(
coordinates,
weights,
basis,
copyData: false);
DoubleMatrixAssert.AreEqual(
expected: basis.GetBasisMatrix(),
actual: cloud.Basis.GetBasisMatrix(),
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: coordinates,
actual: cloud.Coordinates,
delta: CloudTest.Accuracy);
DoubleMatrixAssert.AreEqual(
expected: weights,
actual: cloud.Weights,
delta: CloudTest.Accuracy);
coordinates[0, 0] = Double.PositiveInfinity;
Assert.AreEqual(
expected: coordinates[0, 0],
actual: cloud.Coordinates[0, 0],
delta: CloudTest.Accuracy);
}
}
}
public void ConstructorTest()
{
// Valid input
{
int populationSize = 9;
int sampleSize = 4;
var randomSampling = new SimpleRandomSampling(
populationSize: populationSize,
sampleSize: sampleSize);
Assert.AreEqual(
expected: populationSize,
actual: randomSampling.PopulationSize);
Assert.AreEqual(
expected: sampleSize,
actual: randomSampling.SampleSize);
}
// populationSize <= 1
{
string STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE"),
"1");
int populationSize = 1;
int sampleSize = 4;
ArgumentExceptionAssert.Throw(
() =>
{
var randomSampling = new SimpleRandomSampling(
populationSize: populationSize,
sampleSize: sampleSize);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE,
expectedParameterName: "populationSize");
}
// sampleSize <= 0
{
string STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
int populationSize = 9;
int sampleSize = 0;
ArgumentExceptionAssert.Throw(
() =>
{
var randomSampling = new SimpleRandomSampling(
populationSize: populationSize,
sampleSize: sampleSize);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: "sampleSize");
}
// populationSize <= sampleSize
{
string STR_EXCEPT_PAR_MUST_BE_LESS_THAN_VALUE =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_LESS_THAN_VALUE"),
"the population size");
int populationSize = 9;
int sampleSize = 9;
ArgumentExceptionAssert.Throw(
() =>
{
var randomSampling = new SimpleRandomSampling(
populationSize: populationSize,
sampleSize: sampleSize);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_LESS_THAN_VALUE,
expectedParameterName: "sampleSize");
}
}
public void GetCategoricalEntailmentEnsembleClassifierTest()
{
// state is null
{
string parameterName = "state";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: null,
featureVariables: testableContext.FeatureVariables,
responseVariable: testableContext.ResponseVariable);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// state has wrong count
{
string STR_EXCEPT_CEE_INVALID_STATE_COUNT
= ImplementationServices.GetResourceString(
"STR_EXCEPT_CEE_INVALID_STATE_COUNT");
string parameterName = "state";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 8),
featureVariables: testableContext.FeatureVariables,
responseVariable: testableContext.ResponseVariable);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_CEE_INVALID_STATE_COUNT,
expectedParameterName: parameterName);
}
// featureVariables is null
{
string parameterName = "featureVariables";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, 1.0
}),
featureVariables: null,
responseVariable: testableContext.ResponseVariable);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// featureVariables has wrong count
{
string STR_EXCEPT_CEE_MUST_HAVE_SAME_FEATURES_COUNT
= ImplementationServices.GetResourceString(
"STR_EXCEPT_CEE_MUST_HAVE_SAME_FEATURES_COUNT");
string parameterName = "featureVariables";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, 1.0
}),
featureVariables: new List <CategoricalVariable>(),
responseVariable: testableContext.ResponseVariable);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_CEE_MUST_HAVE_SAME_FEATURES_COUNT,
expectedParameterName: parameterName);
}
// featureVariables contains a variable having wrong number of categories
{
string STR_EXCEPT_CEE_INVALID_FEATURE_CATEGORIES_COUNT
= ImplementationServices.GetResourceString(
"STR_EXCEPT_CEE_INVALID_FEATURE_CATEGORIES_COUNT");
string parameterName = "featureVariables";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, 1.0
}),
featureVariables: new List <CategoricalVariable>()
{
new CategoricalVariable("F")
{
{ 0.0, "A" }, 1.0
}
},
responseVariable: testableContext.ResponseVariable);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_CEE_INVALID_FEATURE_CATEGORIES_COUNT,
expectedParameterName: parameterName);
}
// responseVariable is null
{
string parameterName = "responseVariable";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, 1.0
}),
featureVariables: testableContext.FeatureVariables,
responseVariable: null);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// responseVariable has a wrong number of categories
{
string STR_EXCEPT_CEE_INVALID_RESPONSE_CATEGORIES_COUNT
= ImplementationServices.GetResourceString(
"STR_EXCEPT_CEE_INVALID_RESPONSE_CATEGORIES_COUNT");
string parameterName = "responseVariable";
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
ArgumentExceptionAssert.Throw(
() =>
{
context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, 1.0
}),
featureVariables: testableContext.FeatureVariables,
responseVariable: new CategoricalVariable("R")
{
{ 0.0, "A" }
});
},
expectedType: typeof(ArgumentException),
expectedPartialMessage: STR_EXCEPT_CEE_INVALID_RESPONSE_CATEGORIES_COUNT,
expectedParameterName: parameterName);
}
// valid input
{
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext01.Get();
var context = testableContext.Context;
var actual = context.GetCategoricalEntailmentEnsembleClassifier(
state: DoubleMatrix.Dense(1, 9,
new double[9] {
0, 0, 0, 1, 1, 1, 1, 0, .99
}),
featureVariables: testableContext.FeatureVariables,
responseVariable: testableContext.ResponseVariable);
var expected =
new CategoricalEntailmentEnsembleClassifier(
featureVariables: testableContext.FeatureVariables,
responseVariable: testableContext.ResponseVariable);
expected.Add(
new CategoricalEntailment(
featureVariables: testableContext.FeatureVariables,
responseVariable: testableContext.ResponseVariable,
featurePremises: new List <SortedSet <double> >()
{
new SortedSet <double>()
{
3.0, 4.0, 5.0
}
},
responseConclusion: 0.0,
truthValue: .99));
ListAssert <CategoricalEntailment> .ContainSameItems(
expected : new List <CategoricalEntailment>(expected.Entailments),
actual : new List <CategoricalEntailment>(actual.Entailments),
areEqual : CategoricalEntailmentAssert.AreEqual);
}
}
public void ConstructorTest()
{
// optimizationGoal is not a field of OptimizationGoal
{
var STR_EXCEPT_NOT_FIELD_OF_OPTIMIZATION_GOAL =
ImplementationServices.GetResourceString(
"STR_EXCEPT_NOT_FIELD_OF_OPTIMIZATION_GOAL");
string parameterName = "optimizationGoal";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(2)
{
5, 6
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: (OptimizationGoal)(-1),
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage:
STR_EXCEPT_NOT_FIELD_OF_OPTIMIZATION_GOAL,
expectedParameterName: parameterName);
}
// objectiveFunction is null
{
string parameterName = "objectiveFunction";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: null,
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// featureCategoryCounts is null
{
string parameterName = "featureCategoryCounts";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: null,
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentNullException),
expectedPartialMessage:
ArgumentExceptionAssert.NullPartialMessage,
expectedParameterName: parameterName);
}
// featureCategoryCounts is empty
{
var STR_EXCEPT_PAR_MUST_BE_NON_EMPTY =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_NON_EMPTY");
string parameterName = "featureCategoryCounts";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(),
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_NON_EMPTY,
expectedParameterName: parameterName);
}
// featureCategoryCounts has zero entries
{
var STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE");
string parameterName = "featureCategoryCounts";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 0, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// featureCategoryCounts has negative entries
{
var STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE");
string parameterName = "featureCategoryCounts";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, -1, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// numberOfResponseCategories is zero
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "numberOfResponseCategories";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 0,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// numberOfResponseCategories is negative
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "numberOfResponseCategories";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: -1,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// numberOfCategoricalEntailments is zero
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "numberOfCategoricalEntailments";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 0,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// numberOfCategoricalEntailments is negative
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "numberOfCategoricalEntailments";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: -1,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// minimumNumberOfIterations is zero
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "minimumNumberOfIterations";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 0,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// minimumNumberOfIterations is negative
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "minimumNumberOfIterations";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: -1,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// maximumNumberOfIterations is zero
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "maximumNumberOfIterations";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// maximumNumberOfIterations is negative
{
var STR_EXCEPT_PAR_MUST_BE_POSITIVE =
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_POSITIVE");
string parameterName = "maximumNumberOfIterations";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: -1);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_POSITIVE,
expectedParameterName: parameterName);
}
// minimumNumberOfIterations is greater than maximumNumberOfIterations
{
var STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER"),
"maximumNumberOfIterations",
"minimumNumberOfIterations");
string parameterName = "maximumNumberOfIterations";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .8,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 2);
},
expectedType: typeof(ArgumentException),
expectedPartialMessage:
STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER,
expectedParameterName: parameterName);
}
// probabilitySmoothingCoefficient is zero
{
var STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL"),
"0.0", "1.0");
string parameterName = "probabilitySmoothingCoefficient";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: .0,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL,
expectedParameterName: parameterName);
}
// probabilitySmoothingCoefficient is negative
{
var STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL"),
"0.0", "1.0");
string parameterName = "probabilitySmoothingCoefficient";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: -.1,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL,
expectedParameterName: parameterName);
}
// probabilitySmoothingCoefficient is one
{
var STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL"),
"0.0", "1.0");
string parameterName = "probabilitySmoothingCoefficient";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: 1.0,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL,
expectedParameterName: parameterName);
}
// probabilitySmoothingCoefficient is greater than one
{
var STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL"),
"0.0", "1.0");
string parameterName = "probabilitySmoothingCoefficient";
ArgumentExceptionAssert.Throw(
() =>
{
new CategoricalEntailmentEnsembleOptimizationContext(
objectiveFunction: (x) => Stat.Mean(x),
featureCategoryCounts: new List <int>(3)
{
5, 6, 7
},
numberOfResponseCategories: 3,
numberOfCategoricalEntailments: 4,
allowEntailmentPartialTruthValues: true,
probabilitySmoothingCoefficient: 1.1,
optimizationGoal: OptimizationGoal.Minimization,
minimumNumberOfIterations: 3,
maximumNumberOfIterations: 1000);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage:
STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL,
expectedParameterName: parameterName);
}
// valid input - HigherThanLevel
{
var testableContext = TestableCategoricalEntailmentEnsembleOptimizationContext00.Get();
var context = testableContext.Context;
Assert.AreEqual(
expected: testableContext.StateDimension,
actual: context.StateDimension);
Assert.AreEqual(
expected: testableContext.TraceExecution,
actual: context.TraceExecution);
Assert.AreEqual(
expected: testableContext.EliteSampleDefinition,
actual: context.EliteSampleDefinition);
Assert.AreEqual(
expected: testableContext.OptimizationGoal,
actual: context.OptimizationGoal);
DoubleMatrixAssert.AreEqual(
expected: testableContext.InitialParameter,
actual: context.InitialParameter,
DoubleMatrixTest.Accuracy);
Assert.AreEqual(
expected: testableContext.MinimumNumberOfIterations,
actual: context.MinimumNumberOfIterations);
Assert.AreEqual(
expected: testableContext.MaximumNumberOfIterations,
actual: context.MaximumNumberOfIterations);
Assert.AreEqual(
expected: testableContext.FeatureCategoryCounts.Count,
actual: context.FeatureCategoryCounts.Count);
for (int i = 0; i < context.FeatureCategoryCounts.Count; i++)
{
Assert.AreEqual(
expected: testableContext.FeatureCategoryCounts[i],
actual: context.FeatureCategoryCounts[i]);
}
Assert.AreEqual(
expected: testableContext.NumberOfResponseCategories,
actual: context.NumberOfResponseCategories);
Assert.AreEqual(
expected: testableContext.NumberOfCategoricalEntailments,
actual: context.NumberOfCategoricalEntailments);
Assert.AreEqual(
expected: testableContext.AllowEntailmentPartialTruthValues,
actual: context.AllowEntailmentPartialTruthValues);
Assert.AreEqual(
expected: testableContext.ProbabilitySmoothingCoefficient,
actual: context.ProbabilitySmoothingCoefficient,
delta: DoubleMatrixTest.Accuracy);
}
}
