qp4.java

Go to the documentation of this file.

 
import java.util.*;
import java.lang.Math;
import conopt.*;

public class qp4 {
   public static void main(String argv[]) {
      System.loadLibrary("conoptjni4");
 
      String name = "qp4";
 
      Conopt conopt = new Conopt(name);
      qp4_TutModelData model = new qp4_TutModelData();
      MsgHandler msghdlr = new MsgHandler(name);
 
      model.buildModel();
 
      conopt.loadModel(model);
      conopt.setMessageHandler(msghdlr);
 
      // try to set the license using the environment variables
      try {
         int license_int_1 = Integer.parseInt(System.getenv("CONOPT_LICENSE_INT_1"));
         int license_int_2 = Integer.parseInt(System.getenv("CONOPT_LICENSE_INT_2"));
         int license_int_3 = Integer.parseInt(System.getenv("CONOPT_LICENSE_INT_3"));
         String license_text = System.getenv("CONOPT_LICENSE_TEXT");
 
         conopt.setLicense(license_int_1, license_int_2, license_int_3,
               license_text);
      } catch (Exception e) {
         System.out.println("Unable to set license: " + e.getMessage());
      }
 
      conopt.solve();
 
      conopt.printStatus();
 
      std s = new std();
      int retcode = s.checkSolve(name, conopt.modelStatus(), conopt.solutionStatus(),
            conopt.objectiveValue(), 59978.0, 0.001);
 
      msghdlr.close();
 
      System.exit(retcode);
   }
}
 
class qp4_TutModelData extends ModelData {
   private int NN;
   private int NQ;
   private double[] target;
   private double[] Qdiag;
   private double[] Qlowerdiag;
 
   public qp4_TutModelData() {
      super();
 
      setConstants();
   }
 
   private void setConstants() {
      NN = 1000;
      NQ = NN*2 - 1;
      target = new double[NN];
      Qdiag = new double[NN];
      Qlowerdiag = new double[NN];
      for (int i = 0; i < NN; i++) {
         target[i] = 10;
         Qdiag[i] = 1;
      }
 
      for (int i = 0; i < NN - 1; i++)
         Qlowerdiag[i] = 0.1;
   }

   public void buildModel() {
      // adding the variables to the model
      for (int i = 0; i < NN; i++)
         addVariable(0.0, Conopt.Infinity);
 
      // adding the constraints to the model
      // first we create some arrays to help build the model.
      int[] varindex = new int[NN];
      int[] zeros = new int[NN];
      int[] ones = new int[NN];
      for (int i = 0; i < NN; i++) {
         varindex[i] = i;
         zeros[i] = 0;
         ones[i] = 1;
      }
 
      // the first constraint is the quadratic objective
      addConstraint(ConstraintType.Free, 0.0, varindex,
            Arrays.stream(zeros).asDoubleStream().toArray(), ones);
 
      // the second constraint is the summation constraint: sum(x) == 1
      addConstraint(ConstraintType.Eq, 1.0, varindex,
            Arrays.stream(ones).asDoubleStream().toArray(), zeros);
 
      // setting the objective constraint
      setObjectiveElement(ObjectiveElement.Constraint, 0);
 
      // setting the optimisation direction
      setOptimizationSense(Sense.Minimize);
 
      // setting the second derivative evaluation type
      setSDEvaluationType(SDEvaluationType.Constraint);
 
      // setting the structure of the hessian of the lagrangian
      setLagrangianStructure();
   }
 
   private void setLagrangianStructure() {
      int[] hessianrow = new int[NQ];
      int[] hessiancol = new int[NQ];
 
      // defining the non-zero structure of the hessian
      for (int i = 0; i < NN - 1; i++) {
         hessianrow[2*i] = i;
         hessianrow[2*i + 1] = i + 1;
 
         hessiancol[2*i] = i;
         hessiancol[2*i + 1] = i;
      }
      hessianrow[NQ - 1] = NN - 1;
      hessiancol[NQ - 1] = NN - 1;
 
      // setting the structure of the hessian of the lagrangian
      setSDLagrangianStructure(hessianrow, hessiancol);
   }

   public double evaluateNonlinearTerm(double[] x, int rowno, boolean ignerr, int thread) {
      double g = 0;
      if (rowno == 0) {
         for (int i = 0; i < NN; i++)
            g += (x[i] - target[i])*Qdiag[i]*(x[i] - target[i]);
         for (int i = 0; i < NN - 1; i++)
            g += 2*(x[i + 1] - target[i + 1])*Qlowerdiag[i]*(x[i] - target[i]);
      }
 
      return g/2;
   }

   public void evaluateNonlinearJacobian(double[] x, double[] jac, int rowno, int[] jacnum, boolean ignerr, int thread) {
      assert x.length == jac.length;
 
      if (rowno == 0) {
         for (int i = 0; i < NN; i++)
            jac[i] += Qdiag[i]*(x[i] - target[i]);
 
         for (int i = 0; i < NN - 1; i++) {
            jac[i + 1] += Qlowerdiag[i]*(x[i] - target[i]);
            jac[i] += Qlowerdiag[i]*(x[i + 1] - target[i + 1]);
         }
      }
   }
 

   public void evaluateDirectionalSD(double[] x, double[] dx, double[] d2g, int rowno, int[] jacnum, int thread) {
      assert x.length == d2g.length;
      assert dx.length == d2g.length;
 
      for (int i = 0; i < NN; i++)
         d2g[i] = Qdiag[i]*dx[i];
 
      for (int i = 0; i < NN - 1; i++) {
         d2g[i + 1] += Qlowerdiag[i]*dx[i];
         d2g[i] += Qlowerdiag[i]*dx[i + 1];
      }
   }
 

   public void evaluateSDLagrangian(double[] x, double[] u, int[] hessianrow, int[] hessiancol, double[] hessianval) {
      assert hessianrow.length == hessianval.length;
      assert hessiancol.length == hessianval.length;
 
      for (int i = 0; i < NN - 1; i++) {
         hessianval[2*i] = Qdiag[i]*u[0];
         hessianval[2*i + 1] = Qlowerdiag[i]*u[0];
      }
      hessianval[NQ - 1] = Qdiag[NN - 1]*u[0];
   }
}