pindyck.java

Go to the documentation of this file.

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

public class pindyck {
   public static void main(String argv[]) {
      System.loadLibrary("conoptjni4");
 
      String name = "pindyck";
 
      Conopt conopt = new Conopt(name);
      PindyckModelData model = new PindyckModelData();
      MsgHandler msghdlr = new MsgHandler(name);
 
      // adding the message handler to the conopt interface
      conopt.setMessageHandler(msghdlr);
 
      // building the model
      model.buildModel();
 
      // loading the model in the conopt object
      conopt.loadModel(model);
 
      // 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(), 1170.486, 0.001);
 
      msghdlr.close();
 
      System.exit(retcode);
   }
}
 
class PindyckModelData extends ModelData {
   static final int CONS_SEQ  = 0;
   static final int CONS_DREV = 1;
 
   private int T = 16;   /* Number of time periods */
   private int Vpp = 7;  /* Variables per period */
   private int Epp = 6;  /* Equations per period */
 
   /* the demand vector */
   private double[] demand;
 
   /* index arrays for the variables */
   private int[] vartd;
   private int[] varcs;
   private int[] vars;
   private int[] vard;
   private int[] varr;
   private int[] varp;
   private int[] varrev;
 
   public class IntPair {
      int first_;
      int second_;
 
      public IntPair(int first, int second) {
         first_ = first;
         second_ = second;
      }
 
      public int first() { return first_; }
      public int second() { return second_; }
   };
 
   private final Map<Integer, IntPair> consmapping = new HashMap<>();
 
 
   public PindyckModelData() {
      super();
      InitializeLists();
   }
 
   private void InitializeLists() {
      demand = new double[T];
 
      vartd  = new int[T];
      varcs  = new int[T];
      vars   = new int[T];
      vard   = new int[T];
      varr   = new int[T];
      varp   = new int[T];
      varrev = new int[T];
   }
 

   public void buildModel() {
      // adding the variables to the model
 
      // defining the demand for each time period.
      for (int t = 0; t < T; t++) {
         demand[t] = 1.0 + 2.3 * Math.pow(1.015, t);
      }
 
      // other variables
      int varidx;
      for (int t = 0; t < T; t++) {
         /* td:  Lower=0, Upper=inf, Curr=18 */
         varidx = addVariable(0, Conopt.Infinity, 18);
         vartd[t] = varidx;
 
         /* cs:  Lower=0, Upper=inf, Curr=7*t */
         varidx = addVariable(0, Conopt.Infinity, 7 * (t + 1));
         varcs[t] = varidx;
 
         /* s:   Lower=0, Upper=inf, Curr=7 */
         varidx = addVariable(0, Conopt.Infinity, 7);
         vars[t] = varidx;
 
         /* d:   Lower=0, Upper=inf, Curr=td-s */
         varidx =
               addVariable(0, Conopt.Infinity, getVariable(vartd[t]).getCurr() - getVariable(vars[t]).getCurr());
         vard[t] = varidx;
 
         /* r:   Lower=1, Upper=inf, Curr=r(t-1)-d */
         if (t > 0)
            varidx = addVariable(
                  1, Conopt.Infinity, getVariable(varr[t - 1]).getCurr() - getVariable(vard[t]).getCurr());
         else
            varidx = addVariable(1, Conopt.Infinity, 500 - getVariable(vard[t]).getCurr());
         varr[t] = varidx;
 
         /* p:   Lower=1, Upper=inf, Curr=14 */
         varidx = addVariable(1, Conopt.Infinity, 14);
         varp[t] = varidx;
 
         /* rev: Lower=-inf, Upper=inf, Curr=0 */
         varidx = addVariable(-Conopt.Infinity, Conopt.Infinity);
         varrev[t] = varidx;
      }
 
 
      // adding the objective
      double[] objcoeff  = new double[T];
      int[]    objnlflag = new int[T];
 
      for (int t = 0; t < T; ++t) {
         objcoeff[t] = Math.pow(1.05, 1 - (t + 1));
      }
      int objidx = addConstraint(ConstraintType.Free, 0.0, varrev, objcoeff, objnlflag);
 
 
      // adding the constraints to the model
      int considx;
      for (int t = 0; t < T; t++) {
 
         // adding the tdeq equations
         if (t == 0) {
            {
               int[] index = {vartd[t], varp[t]};  // the variables
               double[] value = {1.0, 0.13};       // the coefficients
               int[] nlflag = {0, 0};              // nlflags
               addConstraint(ConstraintType.Eq, demand[t] + 0.87 * 18.0, index, value, nlflag);
            }
         }
         else {
            {
               int[] index = {vartd[t], vartd[t - 1], varp[t]};
               double[] value = {1.0, -0.87, 0.13};
               int[] nlflag = {0, 0, 0};
               addConstraint(ConstraintType.Eq, demand[t], index, value, nlflag);
 
            }
         }
 
         // adding the seq Equations
         if (t == 0) {
            {
               int[] index = {vars[t], varp[t], varcs[t]};
               double[] value = {1.0, 0.0, 0.0};
               int[] nlflag = {0, 1, 1};
               considx = addConstraint(ConstraintType.Eq, 0.75 * 6.5, index, value, nlflag);
            }
         }
         else {
            {
               int[] index = {vars[t], vars[t - 1], varp[t], varcs[t]};
               double[] value = {1.0, -0.75, 0.0, 0.0};
               int[] nlflag = {0, 0, 1, 1};
               considx = addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
            }
         }
         consmapping.putIfAbsent(considx, new IntPair(CONS_SEQ, t));
 
         // adding the cseq Equations
         if (t == 0) {
            {
               int[] index = {varcs[t], vars[t]};
               double[] value = {1.0, -1.0};
               int[] nlflag = {0, 0};
               addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
            }
         }
         else {
            {
               int[] index = {varcs[t], varcs[t - 1], vars[t]};
               double[] value = {1.0, -1.0, -1.0};
               int[] nlflag = {0, 0, 0};
               addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
            }
         }
 
         // adding the deq equations
         {
               int[] index = {vard[t], vartd[t], vars[t]};
               double[] value = {1.0, -1.0, 1.0};
               int[] nlflag = {0, 0, 0};
               addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
         }
 
         // adding the req equations
         if (t == 0) {
            {
               int[] index = {varr[t], vard[t]};
               double[] value = {1.0, 1.0};
               int[] nlflag = {0, 0};
               addConstraint(ConstraintType.Eq, 500.0, index, value, nlflag);
            }
         }
         else {
            {
               int[] index = {varr[t], varr[t - 1], vard[t]};
               double[] value = {1.0, -1.0, 1.0};
               int[] nlflag = {0, 0, 0};
               addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
            }
         }
 
         // adding the drev equations
         {
               int[] index = {varrev[t], vard[t], varp[t], varr[t]};
               double[] value = {1.0, 0.0, 0.0, 0.0};
               int[] nlflag = {0, 1, 1, 1};
               considx = addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
         }
         consmapping.putIfAbsent(considx, new IntPair(CONS_DREV, t));
      }
 
      // setting the objective constraint
      setObjectiveElement(ObjectiveElement.Constraint, objidx);
 
      // setting the optimisation direction
      setOptimizationSense(Sense.Maximize);
   }

   public double evaluateNonlinearTerm(double[] x, int rowno, boolean ignerr, int thread) {
      IntPair conspair = consmapping.get(rowno);
      if (conspair == null) return 0;
 
      int consset = conspair.first();
      int t       = conspair.second();
 
      assert (consset == CONS_SEQ || consset == CONS_DREV);
      double g = 0;
      if (consset == CONS_SEQ) {
         // seq equation. Nonlinear term = -(1.1+0.1*p(t))*1.02**(-cs(t)/7)
         double h1, h2;
 
         h1 = (1.1 + 0.1 * x[varp[t]]);
         h2 = Math.pow(1.02, -x[varcs[t]] / 7.0);
         g = -h1 * h2;
      }
      else if (consset == CONS_DREV) {
         g = -x[vard[t]] * (x[varp[t]] - 250. / x[varr[t]]);
      }
 
      return g;
   }

   public void evaluateNonlinearJacobian(double[] x, double[] jac, int rowno, int[] jacnum, boolean ignerr, int thread) {
      assert x.length == jac.length;
 
      IntPair conspair = consmapping.get(rowno);
      if (conspair == null) return;
 
      int consset = conspair.first();
      int t       = conspair.second();
 
      assert (consset == CONS_SEQ || consset == CONS_DREV);
 
      if (consset == CONS_SEQ) {
         // seq equation. Nonlinear term = -(1.1+0.1*p(t))*1.02**(-cs(t)/7)
         double h1, h2;
 
         h1 = (1.1 + 0.1 * x[varp[t]]);
         h2 = Math.pow(1.02, -x[varcs[t]] / 7.0);
 
         jac[varcs[t]] = h1 * h2 * Math.log(1.02) / 7.0;
         jac[varp[t]] = -h2 * 0.1;
      }
      else if (consset == CONS_DREV) {
         jac[vard[t]] = -(x[varp[t]] - 250. / x[varr[t]]);
         jac[varr[t]] = -x[vard[t]] * 250. / Math.pow(x[varr[t]], 2);
         jac[varp[t]] = -x[vard[t]];
      }
   }
}