tutorial2.java

Go to the documentation of this file.

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

public class tutorial2 {
   public static void main(String argv[]){
      System.loadLibrary("conopt4_java");
 
      String name = "tutorial2";
 
      Conopt conopt = new Conopt(name);
      Tut2ModelData model = new Tut2ModelData();
      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("LICENSE_INT_1"));
         int license_int_2 = Integer.parseInt(System.getenv("LICENSE_INT_2"));
         int license_int_3 = Integer.parseInt(System.getenv("LICENSE_INT_3"));
         String license_text = System.getenv("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 Tut2ModelData extends ModelData {
   private double Al;
   private double Ak;
   private double Ainp;
   private double Rho;
   private double K;
 
   public Tut2ModelData() {
      super();
 
      setConstants();
   }
 
   private void setConstants() {
      Al   = 0.16;
      Ak   = 2.0;
      Ainp = 0.16;
      Rho  = 1.0;
      K    = 4.0;
   }

   public void buildModel() {
      // adding the variables to the model
      addVariable(0.1, jconoptConstants.CONOPT_INF, 0.5);
      addVariable(0.1, jconoptConstants.CONOPT_INF, 0.5);
      addVariable(0.0, jconoptConstants.CONOPT_INF);
      addVariable(0.0, jconoptConstants.CONOPT_INF);
 
      // adding the constraints to the model
      // Constraint 1
      {
         int[] index = {0, 1, 2, 3};
         double[] value = {-1, -1, 0, 0};
         int[] nlflag = {0, 0, 1, 1};
 
         addConstraint(ConstraintType.Free, -0.1, index, value, nlflag);
      }
 
      // Constraint 2
      {
         int[] index = {0, 1, 2};
         double[] value = {0, 0, -1};
         int[] nlflag = {1, 1, 0};
         addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
      }
 
      // Constraint 3
      {
         int[] index = {2, 3};
         double[] value = {1, 2};
         int[] nlflag = {0, 0};
         addConstraint(ConstraintType.Eq, 4.0, index, value, nlflag);
      }
 
      // setting the objective constraint
      setObjectiveElement(ObjectiveElement.Constraint, 0);
 
      // setting the optimisation direction
      setOptimizationSense(Sense.Maximize);
 
      // setting the structure of the hessian
      int[] rownum = {0, 1, 1, 3};
      int[] colnum = {0, 0, 1, 2};
      setSDLagrangianStructure(rownum, colnum);
   }

   public double evaluateNonlinearTerm(double[] x, int rowno, boolean ignerr, int thread)
   {
      double L   = x[0];
      double Inp = x[1];
      double Out = x[2];
      double P   = x[3];
 
      double g = 0;
      if (rowno == 0)
      {
            g = P * Out;
      }
      else if (rowno == 1)
      {
         double hold1 = (Al*Math.pow(L,(-Rho)) + Ak*Math.pow(K,(-Rho)) + Ainp*Math.pow(Inp,(-Rho)));
         double hold2 = Math.pow(hold1,( -1./Rho ));
 
         g = hold2;
      }
 
      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[0];
      double Inp = x[1];
      double Out = x[2];
      double P   = x[3];
 
      if (rowno == 0)
      {
         jac[2] = P;
         jac[3] = Out;
      }
      else if (rowno == 1)
      {
         double hold1 = (Al*Math.pow(L,(-Rho)) + Ak*Math.pow(K,(-Rho)) + Ainp*Math.pow(Inp,(-Rho)));
         double hold2 = Math.pow(hold1,( -1./Rho ));
         double hold3  = hold2 / hold1;
 
         jac[0] = hold3 * Al   * Math.pow(L  ,(-Rho-1.));
         jac[1] = hold3 * Ainp * Math.pow(Inp,(-Rho-1.));
      }
   }

   public void evaluateSDLagrangian(double x[], double u[], int[] hessianrow, int[] hessiancol, double[] hessianval) {
      double L   = x[0];
      double Inp = x[1];
      double Out = x[2];
      double P   = x[3];
      double hold1, hold2, hold3, hold4;
 
 
      // Normal Evaluation mode
      hessianval[3] = u[0]; // the second derivative of constraint 0 is 1
      if ( u[1] != 0.0 )
      {
         hold1 = (Al*Math.pow(L,-Rho) + Ak*Math.pow(K,-Rho) + Ainp*Math.pow(Inp,-Rho));
         hold2 = Math.pow( hold1,-1.0/Rho);
         hold3 = hold2 / hold1;
 
         /* The code for the first derivative was:
          *    jac(1) = hold3 * Al   * L   ** (-Rho-1.0)
          *    jac(2) = hold3 * Ainp * Inp ** (-Rho-1.0)
          *    Define Hold4 as the derivative of Hold3 with respect to Hold1
          */
         hold4 = hold3 / hold1 * (-1.0/Rho-1.0);
 
         /* The second derivatives are computed as:
          * (1) The derivative of Hold3 multiplied by the other terms PLUS
          * (2) Hold3 multiplied by the derivative of the other terms
          * where the derivative of Hold3 is Hold4 * the derivative of Hold1
          * with respect to the variable in question.
          */
 
         hessianval[0] = hold4 * (-Rho) * Math.pow(Al*Math.pow(L,-Rho-1.0),2) +
            hold3 * Al   * (-Rho-1.0)*Math.pow(L,-Rho-2.0);
         hessianval[1] = hold4 * (-Rho) * (Al*Math.pow(L,-Rho-1.0)) *
            (Ainp*Math.pow(Inp,-Rho-1.0));
         hessianval[2] = hold4 * (-Rho) * Math.pow(Ainp*Math.pow(Inp,-Rho-1.0),2) +
            hold3 * Ainp * (-Rho-1.0)*Math.pow(Inp,-Rho-2.0);
 
 
         // Scale the derivatives with the Lagrange multiplier, u[1]:
         for (int i = 0; i < 3; i++)
            hessianval[i] = hessianval[i] * u[1];
      }
   }
}