square.java

Go to the documentation of this file.

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

public class square {
   public static void main(String argv[]) {
      System.loadLibrary("conoptjni4");
 
      String name = "square";
 
      Conopt conopt = new Conopt(name);
      SquareModelData model = new SquareModelData();
      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);
 
      // tell conopt this is a square system
      conopt.squareModel(1);
 
      // 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());
      }
 
      int coi_error = conopt.solve();
      std s = new std();
      int retcode = 0;
 
      if (coi_error != 0) {
         s.java_log(name, "Errors encountered during solution: " + coi_error);
         retcode = -1;
      }
      // checking the statuses and objective value
      else if (conopt.modelStatus() != 16 || conopt.solutionStatus() != 1) {
         s.java_log(name, "Solver or Model status not as expected (1,16)");
         retcode = -1;
      }
      else {
         // printing the final status of the optimisation
         s.java_log(name, "Successful Solve");
         conopt.printStatus();
      }
 
      msghdlr.close();
      System.exit(retcode);
   }
}
 
class SquareModelData extends ModelData {
 
   private int x0;
   private int x1;
   private int cons1;
   private int cons2;
 
   public SquareModelData() {
      super();
   }

   public void buildModel() {
      //   Model  x0 + x1 = 10
      //          x0 - x1 = 0
      // adding the variables to the model
      x0 = addVariable(-Conopt.Infinity, Conopt.Infinity, 0.0);
      x1 = addVariable(-Conopt.Infinity, Conopt.Infinity, 0.0);
 
      // adding the constraints to the model
      // Constraint 1
      {
         int[] index = {x0, x1};
         double[] value = {1, 1};
         int[] nlflag = {0, 0};
 
         cons1 = addConstraint(ConstraintType.Eq, 10.0, index, value, nlflag);
      }
      
      // Constraint 2
      {
         int[] index = {x0, x1};
         double[] value = {0, 0};
         int[] nlflag = {1, 1}; 
 
 
         cons2 = addConstraint(ConstraintType.Eq, 0.0, index, value, nlflag);
      }
   }

   public double evaluateNonlinearTerm(double[] x, int rowno, boolean ignerr, int thread) {
      double g = 0;
      if (rowno == cons1) {}
 
      else if (rowno == cons2) {
         g = x[x0] - x[x1] ;
      }
 
      return g;
   }

   public void evaluateNonlinearJacobian(double[] x, double[] jac, int rowno, int[] jacnum, boolean ignerr, int thread) {
      assert x.length == jac.length;
 
      if (rowno == cons1) {}
      
      else if (rowno == cons2) {
         jac[x0] = 1 ;
         jac[x1] = -1 ;
      }
   }
}