public void ToDoubleMatrixTest() { // value is null { DoubleMatrix actual = (DoubleMatrixRowCollection)(null); Assert.IsNull(actual); actual = DoubleMatrixRowCollection.ToDoubleMatrix(null); Assert.IsNull(actual); } // value is not null { DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); var expected = matrix; var actual = (DoubleMatrix)rows; DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); actual = DoubleMatrixRowCollection.ToDoubleMatrix(rows); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } }
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 ToDoubleMatrixTest() { // value is null { DoubleMatrix actual = (DoubleMatrixRow)(null); Assert.IsNull(actual); actual = DoubleMatrixRow.ToDoubleMatrix(null); Assert.IsNull(actual); } // value is not null { DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); for (int i = 0; i < matrix.NumberOfRows; i++) { var expected = matrix[i, ":"]; DoubleMatrix actual = rows[i]; DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); actual = DoubleMatrixRow.ToDoubleMatrix(rows[i]); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } } }
public void ToDoubleMatrixTest() { // This code example produces the following output: // // // Part identifier: 0 // indexes: 1 // // Part identifier: 1 // indexes: 0, 5 // // Part identifier: 2 // indexes: 2, 4 // // Part identifier: 3 // indexes: 3 // var target = new IndexPartition <double> { partIndetifiers = new List <double>(3) { 0.0, 1.0, 2.0, 3.0 }, parts = new Dictionary <double, IndexCollection>(3) { { 0.0, IndexCollection.FromArray(new int[] { 1 }) }, { 1.0, IndexCollection.FromArray(new int[] { 0, 5 }) }, { 2.0, IndexCollection.FromArray(new int[] { 2, 4 }) }, { 3.0, IndexCollection.FromArray(new int[] { 3 }) } } }; // Convert the partition to a matrix. var actual = (DoubleMatrix)target; // Conversion of a partition to a matrix: // 1 // 0 // 2 // 3 // 2 // 1 // var expected = DoubleMatrix.Dense(6, 1, new double[] { 1, 0, 2, 3, 2, 1 }); DoubleMatrixAssert.AreEqual(expected, actual, 1e-2); }
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); } }
#pragma warning disable CS0618 // Type or member is obsolete private static void TestSerializationToPath( TestableDoubleMatrix testableMatrix, string partialPath) { // dense { var expected = testableMatrix.AsDense; var path = "dense-" + partialPath; CsvMatrixSerializer.Serialize(path, expected); var actual = CsvMatrixSerializer.Deserialize(path); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // sparse { var expected = testableMatrix.AsSparse; var path = "sparse-" + partialPath; CsvMatrixSerializer.Serialize(path, expected); var actual = CsvMatrixSerializer.Deserialize(path); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // read-only dense { var expected = testableMatrix.AsDense; var path = "read-only-dense-" + partialPath; CsvMatrixSerializer.Serialize(path, expected.AsReadOnly()); var actual = CsvMatrixSerializer.Deserialize(path); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // read-only sparse { var expected = testableMatrix.AsSparse; var path = "read-only-sparse-" + partialPath; CsvMatrixSerializer.Serialize(path, expected.AsReadOnly()); var actual = CsvMatrixSerializer.Deserialize(path); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } }
public void UniformTest() { var values = DoubleMatrix.Dense(3, 2, new double[6] { 1, 2, 3, 4, 5, 6 }); var distribution = FiniteDiscreteDistribution.Uniform(values); DoubleMatrixAssert.AreEqual( expected: values, actual: (DoubleMatrix)distribution.Values, delta: DoubleMatrixTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: DoubleMatrix.Dense(3, 2, 1.0 / 6.0), actual: (DoubleMatrix)distribution.Masses, delta: DoubleMatrixTest.Accuracy); }
public void AsDoubleMatrixTest() { DoubleMatrix expected = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var doubleMatrixRowCollection = expected.AsRowCollection(); var actual = doubleMatrixRowCollection; DoubleMatrixAssert.IsStateAsExpected( expectedState: new DoubleMatrixState( asColumnMajorDenseArray: new double[6] { 1, 2, 3, 4, 5, 6 }, numberOfRows: 2, numberOfColumns: 3), actualMatrix: actual, delta: DoubleMatrixTest.Accuracy); }
public void GetPrincipalProjectionsTest() { var cloud = TestableCloud00.Get().Cloud; var principalProjections = cloud.GetPrincipalProjections(); DoubleMatrixAssert.AreEqual( expected: cloud.Basis.GetBasisMatrix(), actual: principalProjections.ActiveCloud.Basis.GetBasisMatrix(), delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: cloud.Coordinates, actual: principalProjections.ActiveCloud.Coordinates, delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: cloud.Weights, actual: principalProjections.ActiveCloud.Weights, delta: CloudTest.Accuracy); }
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); } }
private static void TestSerializationToStream( TestableDoubleMatrix testableMatrix) { // dense { var expected = testableMatrix.AsDense; MemoryStream stream = new(); var textWriter = new StreamWriter(stream); CsvDoubleMatrixSerializer.Serialize(textWriter, expected); stream.Position = 0; var textReader = new StreamReader(stream); var actual = CsvDoubleMatrixSerializer.Deserialize(textReader); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // sparse { var expected = testableMatrix.AsSparse; MemoryStream stream = new(); var textWriter = new StreamWriter(stream); CsvDoubleMatrixSerializer.Serialize(textWriter, expected); stream.Position = 0; var textReader = new StreamReader(stream); var actual = CsvDoubleMatrixSerializer.Deserialize(textReader); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // read-only dense { var expected = testableMatrix.AsDense; MemoryStream stream = new(); var textWriter = new StreamWriter(stream); CsvDoubleMatrixSerializer.Serialize(textWriter, expected.AsReadOnly()); stream.Position = 0; var textReader = new StreamReader(stream); var actual = CsvDoubleMatrixSerializer.Deserialize(textReader); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } // read-only sparse { var expected = testableMatrix.AsSparse; MemoryStream stream = new(); var textWriter = new StreamWriter(stream); CsvDoubleMatrixSerializer.Serialize(textWriter, expected.AsReadOnly()); stream.Position = 0; var textReader = new StreamReader(stream); var actual = CsvDoubleMatrixSerializer.Deserialize(textReader); DoubleMatrixAssert.AreEqual(expected, actual, DoubleMatrixTest.Accuracy); } }
public void IndexSetTest() { // value is less than 0 { DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); var target = rows[0]; ArgumentExceptionAssert.Throw( () => { target.Index = -1; }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_TAB_INDEX_EXCEEDS_DIMS"), expectedParameterName: "value"); } // value is greater than NumberOfColumns - 1 { DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); var target = rows[0]; ArgumentExceptionAssert.Throw( () => { target.Index = matrix.NumberOfColumns; }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_TAB_INDEX_EXCEEDS_DIMS"), expectedParameterName: "value"); } // Setting Index without changing its value { var subscriber = new PropertyChangedSubscriber(); DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); for (int i = 0; i < matrix.NumberOfRows; i++) { var target = rows[i]; target.PropertyChanged += subscriber.PropertyChangedEventHandler; target.Index = i; Assert.AreEqual(expected: i, actual: target.Index); } } // Setting Index changing its value { var subscriber = new PropertyChangedSubscriber(); DoubleMatrix matrix = DoubleMatrix.Dense(2, 3, new double[6] { 1, 2, 3, 4, 5, 6 }); var rows = matrix.AsRowCollection(); var target = rows[0]; target.PropertyChanged += subscriber.PropertyChangedEventHandler; int expectedIndex = 1; target.Index = expectedIndex; Assert.AreEqual(expectedIndex, target.Index); DoubleMatrixAssert.AreEqual( matrix[expectedIndex, ":"], target, DoubleMatrixTest.Accuracy); } }
public void RunTest() { // Valid input - Minimization { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableSystemPerformanceOptimizationContext00.Get(); var context = testableContext.Context; // Set optimization parameters. double rarity = 0.05; int sampleSize = 1000; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, delta: .03); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } // Valid input - Maximization - with overrides { var optimizer = new SystemPerformanceOptimizer() { PerformanceEvaluationParallelOptions = { MaxDegreeOfParallelism = 1 }, SampleGenerationParallelOptions = { MaxDegreeOfParallelism = 1 } }; // Create the context. var testableContext = TestableSystemPerformanceOptimizationContext01.Get(); var context = testableContext.Context; // Set optimization parameters. double rarity = 0.1; int sampleSize = 1000; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } // Valid input - Maximization - without overrides { var optimizer = new SystemPerformanceOptimizer() { PerformanceEvaluationParallelOptions = { MaxDegreeOfParallelism = 1 }, SampleGenerationParallelOptions = { MaxDegreeOfParallelism = 1 } }; // Create the context. var testableContext = TestableSystemPerformanceOptimizationContext02.Get(); var context = testableContext.Context; // Set optimization parameters. double rarity = 0.1; int sampleSize = 1000; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } }
public void ChangeCoordinatesTest() { // newBasis is null { Basis newBasis = null; var currentCoordinates = DoubleMatrix.Dense(1, 2, new double[2] { 2.0 / 3.0, -1.0 / 3.0 }); var currentBasisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); Basis currentBasis = new(currentBasisMatrix); ArgumentExceptionAssert.Throw( () => { var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "newBasis"); } // currentCoordinates is null { Basis newBasis = Basis.Standard(2); DoubleMatrix currentCoordinates = null; var currentBasisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); Basis currentBasis = new(currentBasisMatrix); ArgumentExceptionAssert.Throw( () => { var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "currentCoordinates"); } // currentBasis is null { Basis newBasis = Basis.Standard(2); var currentCoordinates = DoubleMatrix.Dense(1, 2, new double[2] { 2.0 / 3.0, -1.0 / 3.0 }); Basis currentBasis = null; ArgumentExceptionAssert.Throw( () => { var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "currentBasis"); } // newBasis and currentBasis do not share the same dimension { Basis newBasis = Basis.Standard(1); var currentCoordinates = DoubleMatrix.Dense(1, 2, new double[2] { 2.0 / 3.0, -1.0 / 3.0 }); var currentBasisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); Basis currentBasis = new(currentBasisMatrix); ArgumentExceptionAssert.Throw( () => { var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_BASES_MUST_SHARE_DIMENSION"), expectedParameterName: "newBasis"); } // currentCoordinates has count unequal to basis dimension { Basis newBasis = Basis.Standard(2); var currentCoordinates = DoubleMatrix.Dense(1, 3); var currentBasisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); Basis currentBasis = new(currentBasisMatrix); ArgumentExceptionAssert.Throw( () => { var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_BASIS_COMPLIANT_MATRIX"), expectedParameterName: "currentCoordinates"); } // all parameters are valid { // See example 4, p. 44, Linear Algebra, Lang. var newBasis = Basis.Standard(2); var currentCoordinates = DoubleMatrix.Dense(1, 2, new double[2] { 2.0 / 3.0, -1.0 / 3.0 }); var currentBasisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); var currentBasis = new Basis(currentBasisMatrix); var newCoordinates = Basis.ChangeCoordinates( newBasis, currentCoordinates, currentBasis); var expected = DoubleMatrix.Dense(1, 2, new double[2] { 1, 0 }); var actual = newCoordinates; DoubleMatrixAssert.AreEqual( expected, actual, DoubleMatrixTest.Accuracy); } }
public void GetVectorsTest() { // coordinates is null { var basisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); var basis = new Basis(basisMatrix); ArgumentExceptionAssert.Throw( () => { var vectors = basis.GetVectors(null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "coordinates"); } // coordinates is not a basis compliant matrix { var basisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); var basis = new Basis(basisMatrix); var coordinates = DoubleMatrix.Dense(2, 3); ArgumentExceptionAssert.Throw( () => { var vectors = basis.GetVectors(coordinates); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_BASIS_COMPLIANT_MATRIX"), expectedParameterName: "coordinates"); } // coordinates is valid { var basisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); var basis = new Basis(basisMatrix); var coordinates = DoubleMatrix.Dense(1, 2, new double[2] { 2.0 / 3.0, -1.0 / 3.0 }); var vectors = basis.GetVectors(coordinates); var expected = DoubleMatrix.Dense(1, 2, new double[2] { 1, 0 }); var actual = vectors; DoubleMatrixAssert.AreEqual( expected, actual, DoubleMatrixTest.Accuracy); } }
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); } }
public void NonparametricHessianTest() { // function is null { string parameterName = "function"; ArgumentExceptionAssert.Throw( () => { NumericalDifferentiation.Hessian( function: null, argument: DoubleMatrix.Dense(2, 1)); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // argument is null { string parameterName = "argument"; double function(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; double f = x * x * y + Math.Exp(y); return(f); }; ArgumentExceptionAssert.Throw( () => { NumericalDifferentiation.Hessian( function: function, argument: null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // valid input { double function(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; double f = x * x * y + Math.Exp(y); return(f); }; DoubleMatrix hessian(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; DoubleMatrix h = DoubleMatrix.Dense(2, 2); h[0, 0] = 2.0 * y; h[0, 1] = 2.0 * x; h[1, 0] = h[0, 1]; h[1, 1] = Math.Exp(y); return(h); } var arg = DoubleMatrix.Dense(2, 1, new double[2] { 9.0, -2.1 }); var expected = hessian( argument: arg); var actual = NumericalDifferentiation.Hessian( function: function, argument: arg); DoubleMatrixAssert.AreEqual( expected: expected, actual: actual, delta: DoubleMatrixTest.Accuracy); } }
public void NonparametricGradientTest() { // function is null { string parameterName = "function"; ArgumentExceptionAssert.Throw( () => { NumericalDifferentiation.Gradient( function: null, argument: DoubleMatrix.Dense(2, 1)); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // argument is null { string parameterName = "argument"; double function(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; double f = x * x * y + Math.Exp(y); return(f); }; ArgumentExceptionAssert.Throw( () => { NumericalDifferentiation.Gradient( function: function, argument: null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // valid input - Non zero arguments { double function(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; double f = x * x * y + Math.Exp(y); return(f); }; DoubleMatrix gradient(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; DoubleMatrix g = DoubleMatrix.Dense(2, 1); g[0] = 2.0 * x * y; g[1] = x * x + Math.Exp(y); return(g); }; var arg = DoubleMatrix.Dense(2, 1, new double[2] { 9.0, -2.1 }); var expected = gradient( argument: arg); var actual = NumericalDifferentiation.Gradient( function: function, argument: arg); DoubleMatrixAssert.AreEqual( expected: expected, actual: actual, delta: DoubleMatrixTest.Accuracy); } // valid input - Some zero arguments { double function(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; double f = x * x * y + Math.Exp(y); return(f); }; DoubleMatrix gradient(DoubleMatrix argument) { double x, y; x = argument[0]; y = argument[1]; DoubleMatrix g = DoubleMatrix.Dense(2, 1); g[0] = 2.0 * x * y; g[1] = x * x + Math.Exp(y); return(g); }; var arg = DoubleMatrix.Dense(2, 1, new double[2] { 0.0, -2.1 }); var expected = gradient( argument: arg); var actual = NumericalDifferentiation.Gradient( function: function, argument: arg); DoubleMatrixAssert.AreEqual( expected: expected, actual: actual, delta: DoubleMatrixTest.Accuracy); arg = DoubleMatrix.Dense(2, 1, new double[2] { 9.0, 0.0 }); expected = gradient( argument: arg); actual = NumericalDifferentiation.Gradient( function: function, argument: arg); DoubleMatrixAssert.AreEqual( expected: expected, actual: actual, delta: DoubleMatrixTest.Accuracy); } }
public void RunTest() { // Valid input - Minimization { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableContinuousOptimizationContext00.Get(); var context = testableContext.Context; // Set optimization parameters. int sampleSize = 100; double rarity = 0.09; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, delta: .03); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } // Valid input - Maximization { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableContinuousOptimizationContext01.Get(); var context = testableContext.Context; // Set optimization parameters. int sampleSize = 100; double rarity = 0.1; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } // Valid input - Maximization - not converging { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableContinuousOptimizationContext01.Get(); var context = new ContinuousOptimizationContext( objectiveFunction: testableContext.ObjectiveFunction, initialArgument: testableContext.InitialArgument, meanSmoothingCoefficient: testableContext.MeanSmoothingCoefficient, standardDeviationSmoothingCoefficient: testableContext.StandardDeviationSmoothingCoefficient, standardDeviationSmoothingExponent: testableContext.StandardDeviationSmoothingExponent, initialStandardDeviation: testableContext.InitialStandardDeviation, terminationTolerance: testableContext.TerminationTolerance, optimizationGoal: testableContext.OptimizationGoal, minimumNumberOfIterations: testableContext.MinimumNumberOfIterations, maximumNumberOfIterations: testableContext.MinimumNumberOfIterations + 1); // Set optimization parameters. int sampleSize = 100; double rarity = 0.1; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: false, actual: results.HasConverged); } }
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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: (OptimizationGoal)(-1), terminationTolerance: 1.0e-3, 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 ContinuousOptimizationContext( objectiveFunction: null, initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // initialArgument is null { string parameterName = "initialArgument"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: null, meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // initialArgument is not a row vector { var STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR"); string parameterName = "initialArgument"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(3, 1), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR, expectedParameterName: parameterName); } // initialStandardDeviation is zero { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "initialStandardDeviation"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 0.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // initialStandardDeviation is negative { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "initialStandardDeviation"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: -100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, 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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, 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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, 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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, 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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: -1000); }, 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 ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 2); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER, expectedParameterName: parameterName); } // meanSmoothingCoefficient 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 = "meanSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: 0.0, standardDeviationSmoothingCoefficient: 0.7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // meanSmoothingCoefficient 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 = "meanSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: -.8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // meanSmoothingCoefficient 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 = "meanSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: 1.0, standardDeviationSmoothingCoefficient: 0.7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // meanSmoothingCoefficient 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 = "meanSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: 1.1, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // terminationTolerance is zero { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "terminationTolerance"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 0.0, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // terminationTolerance is negative { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "terminationTolerance"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: -1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // standardDeviationSmoothingCoefficient 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 = "standardDeviationSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: 0.0, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // standardDeviationSmoothingCoefficient 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 = "standardDeviationSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: -.7, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // standardDeviationSmoothingCoefficient 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 = "standardDeviationSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: 1.0, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // standardDeviationSmoothingCoefficient 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 = "standardDeviationSmoothingCoefficient"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: 1.1, standardDeviationSmoothingExponent: 6, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_OPEN_INTERVAL, expectedParameterName: parameterName); } // standardDeviationSmoothingExponent is zero { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "standardDeviationSmoothingExponent"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: 0, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // standardDeviationSmoothingExponent is negative { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "standardDeviationSmoothingExponent"; ArgumentExceptionAssert.Throw( () => { new ContinuousOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(1, 3), meanSmoothingCoefficient: .8, standardDeviationSmoothingCoefficient: .7, standardDeviationSmoothingExponent: -1, initialStandardDeviation: 100.0, optimizationGoal: OptimizationGoal.Minimization, terminationTolerance: 1.0e-3, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // valid input - LowerThanLevel { var testableContext = TestableContinuousOptimizationContext00.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); DoubleMatrixAssert.AreEqual( expected: testableContext.InitialArgument, actual: context.InitialArgument, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.InitialStandardDeviation, actual: context.InitialStandardDeviation, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.MeanSmoothingCoefficient, actual: context.MeanSmoothingCoefficient, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.StandardDeviationSmoothingCoefficient, actual: context.StandardDeviationSmoothingCoefficient, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.StandardDeviationSmoothingExponent, actual: context.StandardDeviationSmoothingExponent); Assert.AreEqual( expected: testableContext.TerminationTolerance, actual: context.TerminationTolerance, delta: DoubleMatrixTest.Accuracy); } // valid input - HigherThanLevel { var testableContext = TestableContinuousOptimizationContext01.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); DoubleMatrixAssert.AreEqual( expected: testableContext.InitialArgument, actual: context.InitialArgument, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.InitialStandardDeviation, actual: context.InitialStandardDeviation, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.MeanSmoothingCoefficient, actual: context.MeanSmoothingCoefficient, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.StandardDeviationSmoothingCoefficient, actual: context.StandardDeviationSmoothingCoefficient, delta: DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.StandardDeviationSmoothingExponent, actual: context.StandardDeviationSmoothingExponent); Assert.AreEqual( expected: testableContext.TerminationTolerance, actual: context.TerminationTolerance, delta: DoubleMatrixTest.Accuracy); } }
public void BasisTest() { // basisMatrix is null { ArgumentExceptionAssert.Throw( () => { var basis = new Basis(null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: "basisMatrix"); } // basisMatrix is not square { var basisMatrix = DoubleMatrix.Dense(2, 3); ArgumentExceptionAssert.Throw( () => { var basis = new Basis(basisMatrix); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_SQUARE"), expectedParameterName: "basisMatrix"); } // basisMatrix is singular { var basisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 2, 2, 4 }); ArgumentExceptionAssert.Throw( () => { var basis = new Basis(basisMatrix); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_NON_SINGULAR"), expectedParameterName: "basisMatrix"); } // basisMatrix is valid (dense) { var basisMatrix = DoubleMatrix.Dense(2, 2, new double[4] { 1, 1, -1, 2 }); var basis = new Basis(basisMatrix); var actual = basis.GetBasisMatrix(); var expected = basisMatrix; DoubleMatrixAssert.AreEqual( expected, actual, DoubleMatrixTest.Accuracy); Assert.AreEqual(2, basis.Dimension); } // basisMatrix is valid (sparse) { var basisMatrix = DoubleMatrix.Identity(2); var basis = new Basis(basisMatrix); var actual = basis.GetBasisMatrix(); var expected = basisMatrix; DoubleMatrixAssert.AreEqual( expected, actual, DoubleMatrixTest.Accuracy); Assert.AreEqual(2, basis.Dimension); } }
public void AnalyzeTest() { // data is null { string parameterName = "data"; DoubleMatrix data = null; DoubleMatrix individualWeights = DoubleMatrix.Dense(1, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // individualWeights is null { string parameterName = "individualWeights"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = null; DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // variableCoefficients is null { string parameterName = "variableCoefficients"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0);; DoubleMatrix variableCoefficients = null; ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, 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 = "individualWeights"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(1, 4, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR, expectedParameterName: parameterName); } // individualWeights must have the number of rows of data { 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"), "data"); string parameterName = "individualWeights"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(5, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_ROWS, expectedParameterName: parameterName); } // individualWeights 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 = "individualWeights"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, -1.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_BE_NON_NEGATIVE, expectedParameterName: parameterName); } // individualWeights 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 = "individualWeights"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, new double[4] { .3, .6, .2, .1 }); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1, expectedParameterName: parameterName); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_SUM_TO_1, expectedParameterName: parameterName); } // variableCoefficients must be a row vector { var STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR"); string parameterName = "variableCoefficients"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 2, 1, new double[2] { 9, 4 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR, expectedParameterName: parameterName); } // variableCoefficients must have the number of columns of data { var STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS = string.Format(CultureInfo.InvariantCulture, ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS"), "data"); string parameterName = "variableCoefficients"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 3, new double[3] { 9, 4, 5 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_HAVE_SAME_NUM_OF_COLUMNS, expectedParameterName: parameterName); } // variableCoefficients must have positive entries { var STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE"); string parameterName = "variableCoefficients"; DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 0 }); ArgumentExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_ENTRIES_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // SVD cannot be executed or does not converge { var STR_EXCEPT_SVD_ERRORS = ImplementationServices.GetResourceString( "STR_EXCEPT_SVD_ERRORS"); DoubleMatrix data = DoubleMatrix.Dense(2, 2, new double[4] { Double.NegativeInfinity, 0, 0, 1 }); DoubleMatrix individualWeights = DoubleMatrix.Dense(2, 1, 1.0 / 2.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 1, 1 }); ExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(InvalidOperationException), expectedMessage: STR_EXCEPT_SVD_ERRORS); } // No positive principal variances { var STR_EXCEPT_GDA_NON_POSITIVE_PRINCIPAL_VARIANCES = ImplementationServices.GetResourceString( "STR_EXCEPT_GDA_NON_POSITIVE_PRINCIPAL_VARIANCES"); DoubleMatrix data = DoubleMatrix.Dense(4, 2); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 1, 1 }); ExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); }, expectedType: typeof(InvalidOperationException), expectedMessage: STR_EXCEPT_GDA_NON_POSITIVE_PRINCIPAL_VARIANCES); ExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data, individualWeights); }, expectedType: typeof(InvalidOperationException), expectedMessage: STR_EXCEPT_GDA_NON_POSITIVE_PRINCIPAL_VARIANCES); ExceptionAssert.Throw( () => { PrincipalComponents.Analyze( data); }, expectedType: typeof(InvalidOperationException), expectedMessage: STR_EXCEPT_GDA_NON_POSITIVE_PRINCIPAL_VARIANCES); } // Valid input { { DoubleMatrix data = DoubleMatrix.Dense(4, 2, new double[8] { 1, 2, 3, 4, 5, 6, 7, 0 }); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); DoubleMatrix variableCoefficients = DoubleMatrix.Dense( 1, 2, new double[2] { 9, 4 }); var principalComponents = PrincipalComponents.Analyze( data, individualWeights, variableCoefficients); var cloud = principalComponents.ActiveCloud; DoubleMatrixAssert.AreEqual( expected: new Basis( DoubleMatrix.Dense(2, 2, new double[4] { 3, 0, 0, 2 })) .GetBasisMatrix(), actual: cloud.Basis.GetBasisMatrix(), delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: data, actual: cloud.Coordinates, delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: individualWeights, actual: cloud.Weights, delta: CloudTest.Accuracy); data[0, 0] = Double.PositiveInfinity; Assert.AreNotEqual( notExpected: data[0, 0], actual: cloud.Coordinates[0, 0], delta: CloudTest.Accuracy); } { DoubleMatrix data = DoubleMatrix.Dense(4, 2, new double[8] { 1, 2, 3, 4, 5, 6, 7, 0 }); DoubleMatrix individualWeights = DoubleMatrix.Dense(4, 1, 1.0 / 4.0); var principalComponents = PrincipalComponents.Analyze( data, individualWeights); var cloud = principalComponents.ActiveCloud; DoubleMatrixAssert.AreEqual( expected: Basis.Standard(2) .GetBasisMatrix(), actual: cloud.Basis.GetBasisMatrix(), delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: data, actual: cloud.Coordinates, delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: individualWeights, actual: cloud.Weights, delta: CloudTest.Accuracy); data[0, 0] = Double.PositiveInfinity; Assert.AreNotEqual( notExpected: data[0, 0], actual: cloud.Coordinates[0, 0], delta: CloudTest.Accuracy); } { DoubleMatrix data = DoubleMatrix.Dense(4, 2, new double[8] { 1, 2, 3, 4, 5, 6, 7, 0 }); var principalComponents = PrincipalComponents.Analyze( data); var cloud = principalComponents.ActiveCloud; DoubleMatrixAssert.AreEqual( expected: Basis.Standard(2) .GetBasisMatrix(), actual: cloud.Basis.GetBasisMatrix(), delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: data, actual: cloud.Coordinates, delta: CloudTest.Accuracy); DoubleMatrixAssert.AreEqual( expected: DoubleMatrix.Dense(4, 1, 1.0 / 4.0), actual: cloud.Weights, delta: CloudTest.Accuracy); data[0, 0] = Double.PositiveInfinity; Assert.AreNotEqual( notExpected: data[0, 0], actual: cloud.Coordinates[0, 0], delta: CloudTest.Accuracy); } } }
public void RunTest() { // Valid input - Minimization { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableCombinationOptimizationContext00.Get(); var context = testableContext.Context; // Set optimization parameters. int sampleSize = 300; double rarity = 0.01; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, delta: .03); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.Accuracy); } // Valid input - Maximization { var optimizer = new SystemPerformanceOptimizer(); // Create the context. var testableContext = TestableCombinationOptimizationContext01.Get(); var context = testableContext.Context; // Set optimization parameters. int sampleSize = 300; double rarity = 0.01; // Solve the problem. var results = optimizer.Optimize( context, rarity, sampleSize); Assert.AreEqual( expected: true, actual: results.HasConverged); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: results.OptimalState, DoubleMatrixTest.Accuracy); Assert.AreEqual( expected: testableContext.OptimalPerformance, actual: results.OptimalPerformance, DoubleMatrixTest.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 ParametricMinimizeTest() { // objectiveFunction is null { string parameterName = "objectiveFunction"; ArgumentExceptionAssert.Throw( () => { ContinuousOptimization.Minimize( objectiveFunction: (Func <DoubleMatrix, DoubleMatrix, double>)null, initialArgument: DoubleMatrix.Dense(1, 1, -6.0), functionParameter: null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // initialArgument is null { string parameterName = "initialArgument"; ArgumentExceptionAssert.Throw( () => { ContinuousOptimization.Minimize <DoubleMatrix>( objectiveFunction: (x, p) => Stat.Mean(x), initialArgument: null, functionParameter: null); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // initialArgument is not a row vector { var STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR"); string parameterName = "initialArgument"; ArgumentExceptionAssert.Throw( () => { ContinuousOptimization.Minimize <DoubleMatrix>( objectiveFunction: (x, p) => Stat.Mean(x), initialArgument: DoubleMatrix.Dense(2, 1, -6.0), functionParameter: null); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_ROW_VECTOR, expectedParameterName: parameterName); } // Valid input { var testableContext = TestableContinuousOptimizationContext00 .Get(); double objectiveFunction(DoubleMatrix argument, double parameter) { return(parameter * testableContext.Context.Performance(argument)); }; var actual = ContinuousOptimization.Minimize( objectiveFunction: objectiveFunction, initialArgument: DoubleMatrix.Dense(1, 1, -3.0), functionParameter: 2.0); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: actual, delta: DoubleMatrixTest.Accuracy); } // Valid input { int numberOfArguments = 10; var testableContext = TestableContinuousOptimizationContext03 .Get(numberOfArguments); double objectiveFunction(DoubleMatrix argument, double parameter) { return(parameter * testableContext.Context.Performance(argument)); }; var actual = ContinuousOptimization.Minimize( objectiveFunction: objectiveFunction, initialArgument: DoubleMatrix.Dense(1, numberOfArguments, 5.0), functionParameter: 2.0); DoubleMatrixAssert.AreEqual( expected: testableContext.OptimalState, actual: actual, delta: DoubleMatrixTest.Accuracy); } }
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() { // 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: null, stateDimension: 7, partitionDimension: 2, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // stateDimension is zero { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "stateDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 0, partitionDimension: 2, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // stateDimension is negative { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "stateDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: -1, partitionDimension: 2, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // partitionDimension is zero { var STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE"), "1"); string parameterName = "partitionDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 0, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE, expectedParameterName: parameterName); } // partitionDimension is one { var STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE"), "1"); string parameterName = "partitionDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 1, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE, expectedParameterName: parameterName); } // partitionDimension is negative { var STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE"), "1"); string parameterName = "partitionDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: -1, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_VALUE, expectedParameterName: parameterName); } // partitionDimension is equal to stateDimension { var STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER"), "partitionDimension", "stateDimension"); string parameterName = "partitionDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 7, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER, expectedParameterName: parameterName); } // partitionDimension is greater than stateDimension { var STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER = string.Format( ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER"), "partitionDimension", "stateDimension"); string parameterName = "partitionDimension"; ArgumentExceptionAssert.Throw( () => { new PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 8, probabilitySmoothingCoefficient: .8, optimizationGoal: OptimizationGoal.Minimization, minimumNumberOfIterations: 3, maximumNumberOfIterations: 1000); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_LESS_THAN_OTHER, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 PartitionOptimizationContext( objectiveFunction: (x) => Stat.Mean(x), stateDimension: 7, partitionDimension: 2, 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 - LowerThanLevel { var testableContext = TestablePartitionOptimizationContext00.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.PartitionDimension, actual: context.PartitionDimension); Assert.AreEqual( expected: testableContext.ProbabilitySmoothingCoefficient, actual: context.ProbabilitySmoothingCoefficient, delta: 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 ConstructorTest() { // stateDimension is not positive { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "stateDimension"; ArgumentExceptionAssert.Throw( () => { new SystemPerformanceOptimizationContext00( stateDimension: 0, optimizationGoal: OptimizationGoal.Minimization, initialParameter: DoubleMatrix.Dense(2, 2, new double[] { -1.0, 10000.0, -1.0, 10000.0 }), minimumNumberOfIterations: 3, maximumNumberOfIterations: 10000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // 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 SystemPerformanceOptimizationContext00( stateDimension: 2, optimizationGoal: (OptimizationGoal)(-1), initialParameter: DoubleMatrix.Dense(2, 2, new double[] { -1.0, 10000.0, -1.0, 10000.0 }), minimumNumberOfIterations: 3, maximumNumberOfIterations: 10000); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_NOT_FIELD_OF_OPTIMIZATION_GOAL, expectedParameterName: parameterName); } // initialParameter is null { string parameterName = "initialParameter"; ArgumentExceptionAssert.Throw( () => { new SystemPerformanceOptimizationContext00( stateDimension: 2, optimizationGoal: OptimizationGoal.Minimization, initialParameter: null, minimumNumberOfIterations: 3, maximumNumberOfIterations: 10000); }, expectedType: typeof(ArgumentNullException), expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage, expectedParameterName: parameterName); } // minimumNumberOfIterations is not positive { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "minimumNumberOfIterations"; ArgumentExceptionAssert.Throw( () => { new SystemPerformanceOptimizationContext00( stateDimension: 2, optimizationGoal: OptimizationGoal.Minimization, initialParameter: DoubleMatrix.Dense(2, 2, new double[] { -1.0, 10000.0, -1.0, 10000.0 }), minimumNumberOfIterations: 0, maximumNumberOfIterations: 10000); }, expectedType: typeof(ArgumentOutOfRangeException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_POSITIVE, expectedParameterName: parameterName); } // maximumNumberOfIterations is not positive { var STR_EXCEPT_PAR_MUST_BE_POSITIVE = ImplementationServices.GetResourceString( "STR_EXCEPT_PAR_MUST_BE_POSITIVE"); string parameterName = "maximumNumberOfIterations"; ArgumentExceptionAssert.Throw( () => { new SystemPerformanceOptimizationContext00( stateDimension: 2, optimizationGoal: OptimizationGoal.Minimization, initialParameter: DoubleMatrix.Dense(2, 2, new double[] { -1.0, 10000.0, -1.0, 10000.0 }), minimumNumberOfIterations: 3, maximumNumberOfIterations: 0); }, 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 SystemPerformanceOptimizationContext00( stateDimension: 2, optimizationGoal: OptimizationGoal.Minimization, initialParameter: DoubleMatrix.Dense(2, 2, new double[] { -1.0, 10000.0, -1.0, 10000.0 }), minimumNumberOfIterations: 3, maximumNumberOfIterations: 2); }, expectedType: typeof(ArgumentException), expectedPartialMessage: STR_EXCEPT_PAR_MUST_BE_GREATER_THAN_OTHER, expectedParameterName: parameterName); } // valid input - LowerThanLevel { var testableContext = TestableSystemPerformanceOptimizationContext00.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); } // valid input - HigherThanLevel { var testableContext = TestableSystemPerformanceOptimizationContext01.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); } }