tutorial2r.java

Go to the documentation of this file.

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

public class tutorial2r {
   public static void main(String argv[]) {
      System.loadLibrary("conoptjni4");
 
      String name = "tutorial2r";
 
      Conopt conopt = new Conopt(name);
      Tut2rModelData model = new Tut2rModelData();
      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(), 0.572943, 0.000001);
 
      msghdlr.close();
 
      System.exit(retcode);
   }
}
 
class Tut2rModelData extends ModelData {
   private double Al;
   private double Ak;
   private double Ainp;
   private double Rho;
   private double K;
 
   /* declaring the variable and constraint indices. */
   private int varl;
   private int varinp;
   private int varout;
   private int varp;
   private int varint;
   private int consobj;
   private int consprod;
   private int consnew;
 
   public Tut2rModelData() {
      super();
 
      setConstants();
   }
 
   private void setConstants() {
      Al   = 0.16;
      Ak   = 2.0;
      Ainp = 0.16;
      Rho  = 1.0;
      K    = 4.0;
   }

   public void buildModel() {
   
      double initL = 0.5;
      double initInp = 0.5;
 
      // adding the variables to the model
      varl = addVariable(0.1, Conopt.Infinity, initL);
      varinp = addVariable(0.1, Conopt.Infinity, initInp);
      varout = addVariable(0.0, Conopt.Infinity);
      varp = addVariable(0.0, Conopt.Infinity);
 
      // Lower bound on the new Int is set to 0.01 and the initial
      // value is defined from row 1
      varint = addVariable(0., Conopt.Infinity,
               Al * Math.pow(initL, -Rho) + Ak * Math.pow(K, -Rho) + Ainp * Math.pow(initInp, -Rho));
 
      // adding the constraints to the model
      // Constraint 1
      {
         int[] index = {varl, varinp, varout, varp};
         double[] value = {-1, -1, 0, 0};
         int[] nlflag = {0, 0, 1, 1};
 
         consobj = addConstraint(ConstraintType.Free, -0.1, index, value, nlflag);
      }
 
      // Constraint 2
      {
         int[] index = {varl, varinp, varint};
         double[] value = {0, 0, -1};
         int[] nlflag = {1, 1, 0};
         consprod = addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
      }
 
      // Constraint 3
      {
         int[] index = {varout, varp};
         double[] value = {1, 2};
         int[] nlflag = {0, 0};
         addConstraint(ConstraintType.Eq, 4.0, index, value, nlflag);
      }
 
      // Constraint 4
      {
         int[] index = {varout, varint};
         double[] value = {-1, 0};
         int[] nlflag = {0, 1};
         consnew = addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
      }
 
      // setting the objective constraint
      setObjectiveElement(ObjectiveElement.Constraint, consobj);
 
      // setting the optimisation direction
      setOptimizationSense(Sense.Maximize);
 
      // setting the structure of the hessian
      int[] rownum = {0, 1, 3, 4};
      int[] colnum = {0, 1, 2, 4};
      setSDLagrangianStructure(rownum, colnum);
   }

   public double evaluateNonlinearTerm(double[] x, int rowno, boolean ignerr, int thread) {
      double L   = x[varl];
      double Inp = x[varinp];
      double Out = x[varout];
      double P   = x[varp];
      double Int = x[varint];
 
      double g = 0;
      if (rowno == consobj) {
         g = P * Out;
      }
      else if (rowno == consprod) {
         g = (Al * Math.pow(L, (-Rho)) + Ak * Math.pow(K, (-Rho)) + Ainp * Math.pow(Inp, (-Rho)));
      }
      else if (rowno == consnew) {
         g = Math.pow(Int, (-1.0 / Rho));
      }
 
      return g;
   }

   public void evaluateNonlinearJacobian(double[] x, double[] jac, int rowno, int[] jacnum, boolean ignerr,
         int thread) {
      assert x.length == jac.length;
 
      double L   = x[varl];
      double Inp = x[varinp];
      double Out = x[varout];
      double P   = x[varp];
      double Int = x[varint];
 
      if (rowno == consobj) {
         jac[varout] = P;
         jac[varp] = Out;
      }
      else if (rowno == consprod) {
         jac[varl] = Al * (-Rho) * Math.pow(L, (-Rho - 1.));       /* derivative w.r.t. L   = X[0]  */
         jac[varinp] = Ainp * (-Rho) * Math.pow(Inp, (-Rho - 1.)); /* derivative w.r.t. Inp = X[1]  */
      }
      else if (rowno == consnew) {
         jac[varint] = (-1.0 / Rho) * Math.pow(Int, (-1.0 / Rho - 1.0));
      }
   }

   public void evaluateSDLagrangian(double x[], double u[], int[] hessianrow, int[] hessiancol, double[] hessianval) {
      double L;
      double Inp;
 
      // Normal Evaluation mode
      hessianval[2] = u[consobj]; // the second derivative of constraint 0 is 1
      if ( u[consprod] != 0.0 ) {
         L   = x[varl];
         Inp = x[varinp];
 
         hessianval[0] = (-Rho) * (-Rho - 1.0) * Al * Math.pow(L, -Rho - 2.0) * u[consprod];
         hessianval[1] = (-Rho) * (-Rho - 1.0) * Ainp * Math.pow(Inp, -Rho - 2.0) * u[consprod];
      };
      if (u[consnew] != 0.0)
         hessianval[3] = (-1.0 / Rho) * (-1.0 / Rho - 1.0) * Math.pow(x[varint], -1.0 / Rho - 2.0);
   }
}