View Javadoc
1   /*
2    * Licensed to the Hipparchus project under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.hipparchus.optim.nonlinear.vector.constrained;
18  
19  import org.hipparchus.exception.LocalizedCoreFormats;
20  import org.hipparchus.exception.MathIllegalArgumentException;
21  import org.hipparchus.linear.MatrixUtils;
22  import org.hipparchus.linear.RealMatrix;
23  import org.hipparchus.linear.RealVector;
24  import org.hipparchus.optim.nonlinear.scalar.ObjectiveFunction;
25  import org.junit.jupiter.api.Test;
26  
27  import static org.junit.jupiter.api.Assertions.assertEquals;
28  import static org.junit.jupiter.api.Assertions.fail;
29  
30  class AbstractSQPOptimizerTest {
31  
32      @Test
33      void testLagrangianGradX() {
34          // GIVEN
35          final TestSQPOptimizer testSQPOptimizer = new TestSQPOptimizer();
36          final TwiceDifferentiableFunction multivariateFunction = new RosenbrockFunction();
37          final ObjectiveFunction objectiveFunction = new ObjectiveFunction(multivariateFunction);
38          testSQPOptimizer.parseOptimizationData(objectiveFunction);
39          final RealVector expectedVector = MatrixUtils.createRealVector(new double[] { 1 });
40          // WHEN
41          final RealVector actualVector = testSQPOptimizer.lagrangianGradX(expectedVector, null,null, null);
42          // THEN
43          for (int i = 0; i < expectedVector.getDimension(); i++) {
44              assertEquals(expectedVector.getEntry(i), actualVector.getEntry(i), 0);
45          }
46      }
47  
48      @Test
49      void testParseOptimizationData() {
50          // GIVEN
51          final TestSQPOptimizer testSQPOptimizer = new TestSQPOptimizer();
52          final SQPOption expectedOptions = new SQPOption();
53          final TwiceDifferentiableFunction multivariateFunction = new RosenbrockFunction();
54          final ObjectiveFunction objectiveFunction = new ObjectiveFunction(multivariateFunction);
55          // WHEN
56          testSQPOptimizer.parseOptimizationData(objectiveFunction, expectedOptions);
57          // THEN
58          assertEquals(expectedOptions, testSQPOptimizer.getSettings());
59      }
60  
61      @Test
62      void testParseOptimizationDataException() {
63          // GIVEN
64          final TestSQPOptimizer testSQPOptimizer = new TestSQPOptimizer();
65          final EqualityConstraint equalityConstraint = new TestEqualityConstraints(100000);
66          final TwiceDifferentiableFunction multivariateFunction = new RosenbrockFunction();
67          final ObjectiveFunction objectiveFunction = new ObjectiveFunction(multivariateFunction);
68          // WHEN
69          try {
70              testSQPOptimizer.parseOptimizationData(objectiveFunction, equalityConstraint);
71              fail();
72          } catch (final MathIllegalArgumentException exception) {
73              assertEquals("rank of constraints must be lesser than domain dimension, but 100,000 >= 2",
74                      exception.getMessage());
75          }
76      }
77  
78      @Test
79      void testParseOptimizationDataException2() {
80          // GIVEN
81          final TestSQPOptimizer testSQPOptimizer = new TestSQPOptimizer();
82          final EqualityConstraint equalityConstraint = new TestEqualityConstraints(0);
83          final TwiceDifferentiableFunction multivariateFunction = new RosenbrockFunction();
84          final ObjectiveFunction objectiveFunction = new ObjectiveFunction(multivariateFunction);
85          // WHEN
86          try {
87              testSQPOptimizer.parseOptimizationData(objectiveFunction, equalityConstraint);
88              fail();
89          } catch (final MathIllegalArgumentException exception) {
90              assertEquals(LocalizedCoreFormats.ZERO_NOT_ALLOWED.getSourceString(),
91                      exception.getMessage());
92          }
93      }
94  
95      private static class TestSQPOptimizer extends AbstractSQPOptimizer {
96  
97          TestSQPOptimizer() {
98              super();
99          }
100 
101         @Override
102         protected LagrangeSolution doOptimize() {
103             return null;
104         }
105     }
106 
107     private static class TestEqualityConstraints extends EqualityConstraint {
108 
109         private final int dimension;
110 
111         TestEqualityConstraints(final int dimension) {
112             super(MatrixUtils.createRealVector(new double[dimension]));
113             this.dimension = dimension;
114         }
115 
116         @Override
117         public int dim() {
118             return dimension;
119         }
120 
121         @Override
122         public RealVector value(RealVector x) {
123             return null;
124         }
125 
126         @Override
127         public RealMatrix jacobian(RealVector x) {
128             return null;
129         }
130     }
131 
132 }