1 /* 2 * Licensed to the Apache Software Foundation (ASF) 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 ASF 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 * http://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.apache.commons.math4.legacy.optim.linear; 18 19 import java.util.Collection; 20 import java.util.Collections; 21 22 import org.apache.commons.math4.legacy.exception.TooManyIterationsException; 23 import org.apache.commons.math4.legacy.optim.OptimizationData; 24 import org.apache.commons.math4.legacy.optim.PointValuePair; 25 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimizer; 26 27 /** 28 * Base class for implementing linear optimizers. 29 * 30 * @since 3.1 31 */ 32 public abstract class LinearOptimizer 33 extends MultivariateOptimizer { 34 /** 35 * Linear objective function. 36 */ 37 private LinearObjectiveFunction function; 38 /** 39 * Linear constraints. 40 */ 41 private Collection<LinearConstraint> linearConstraints; 42 /** 43 * Whether to restrict the variables to non-negative values. 44 */ 45 private boolean nonNegative; 46 47 /** 48 * Simple constructor with default settings. 49 * 50 */ 51 protected LinearOptimizer() { 52 super(null); // No convergence checker. 53 } 54 55 /** 56 * @return {@code true} if the variables are restricted to non-negative values. 57 */ 58 protected boolean isRestrictedToNonNegative() { 59 return nonNegative; 60 } 61 62 /** 63 * @return the optimization type. 64 */ 65 protected LinearObjectiveFunction getFunction() { 66 return function; 67 } 68 69 /** 70 * @return the optimization type. 71 */ 72 protected Collection<LinearConstraint> getConstraints() { 73 return Collections.unmodifiableCollection(linearConstraints); 74 } 75 76 /** 77 * {@inheritDoc} 78 * 79 * @param optData Optimization data. In addition to those documented in 80 * {@link MultivariateOptimizer#parseOptimizationData(OptimizationData[]) 81 * MultivariateOptimizer}, this method will register the following data: 82 * <ul> 83 * <li>{@link LinearObjectiveFunction}</li> 84 * <li>{@link LinearConstraintSet}</li> 85 * <li>{@link NonNegativeConstraint}</li> 86 * </ul> 87 * @return {@inheritDoc} 88 * @throws TooManyIterationsException if the maximal number of 89 * iterations is exceeded. 90 */ 91 @Override 92 public PointValuePair optimize(OptimizationData... optData) 93 throws TooManyIterationsException { 94 // Set up base class and perform computation. 95 return super.optimize(optData); 96 } 97 98 /** 99 * Scans the list of (required and optional) optimization data that 100 * characterize the problem. 101 * 102 * @param optData Optimization data. 103 * The following data will be looked for: 104 * <ul> 105 * <li>{@link LinearObjectiveFunction}</li> 106 * <li>{@link LinearConstraintSet}</li> 107 * <li>{@link NonNegativeConstraint}</li> 108 * </ul> 109 */ 110 @Override 111 protected void parseOptimizationData(OptimizationData... optData) { 112 // Allow base class to register its own data. 113 super.parseOptimizationData(optData); 114 115 // The existing values (as set by the previous call) are reused if 116 // not provided in the argument list. 117 for (OptimizationData data : optData) { 118 if (data instanceof LinearObjectiveFunction) { 119 function = (LinearObjectiveFunction) data; 120 continue; 121 } 122 if (data instanceof LinearConstraintSet) { 123 linearConstraints = ((LinearConstraintSet) data).getConstraints(); 124 continue; 125 } 126 if (data instanceof NonNegativeConstraint) { 127 nonNegative = ((NonNegativeConstraint) data).isRestrictedToNonNegative(); 128 continue; 129 } 130 } 131 } 132 }