ampl.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Stefan Vigerske


#ifndef AMPL_H
#define AMPL_H

#include "standard.h"

#ifdef COIN_HAS_ASL

#include "func.h"
#include "problem.h"

#include "asl.h"
#undef filename

extern ASL *asl;

class ampl {
private:
  Pointer<char> stubfile;

public:

  ampl(char* stubfile_) {
    if (! stubfile_) {
      out_err << "ampl::ampl: Given filename was NULL !" << endl;
      exit(-1);
    }
    stubfile = strdup(stubfile_);
  }

  Pointer<MinlpProblem> get_problem();

  void write_sol_file(const UserVector<double>& sol_point, char* message="") {
    write_sol(message, (double*)(const Pointer<double>)sol_point, NULL, NULL);
  }

};

class amplObj : public Func {
private:
        Func::CurvatureType curv_type;
public:
  amplObj(int dim_=0, Pointer<SparsityInfo> sparsity_=NULL, Pointer<ostream> out_func_p_=out_out_p, Pointer<ostream> out_func_log_p_=out_log_p)
  : Func(dim_, out_func_p_, out_func_log_p_)
  { sparsity=sparsity_;
  }

  double eval(const UserVector<double>& x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error evaluating objective" << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
            write_sol("ASL-error evaluating objective, aborted", (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
          }
    return objval(0, (double*)(const Pointer<double>)x, NULL);
  }

        void grad(dvector& g, const dvector& x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error evaluating gradient of objective" << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
            write_sol("ASL-error computing gradient of objective, aborted", (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
          }
    objgrd(0, (double*)(const Pointer<double>)x, (double*)(Pointer<double>)g, NULL);
        }

  void grad(UserVector<double>& g, const UserVector<double>& x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error computing gradient of objective" << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
            write_sol("ASL-error computing gradient of objective, aborted", (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
          }
    double* gr=new double[g.size()];
    objgrd(0, (double*)(const Pointer<double>)x, gr, NULL);
    g.set(gr, g.dim());
    delete gr;
  }
        
        using Func::grad;

  void HessMult(dvector& y, const dvector& x, const dvector& z) const {
    eval(x);
    hvcomp((double*)(const Pointer<double>)y, (double*)(const Pointer<double>)z, 0, NULL, NULL);
  }

  void HessMult(UserVector<double>& y, const UserVector<double>& x, const UserVector<double>& z) const {
    eval(x);
    double* y0=new double[y.size()];
    hvcomp(y0, (double*)(const Pointer<double>)z, 0, NULL, NULL);
    y.set(y0, y.dim());
    delete y0;
  }
        
        using Func::HessMult;

        void set_curvature(CurvatureType ct) { curv_type=ct; };
        CurvatureType get_curvature() const { return curv_type; };

  void print(ostream& out) const {
    out << "amplObj: dim=" << dim() << endl;
  }

};

class amplCon : public Func {
private:
  fint connr;

  Pointer<real> con_select;

        Func::CurvatureType curv_type;
public:
  amplCon(int connr_, int dim_=0, Pointer<SparsityInfo> sparsity_=NULL, Pointer<ostream> out_func_p_=out_out_p, Pointer<ostream> out_func_log_p_=out_log_p)
  : Func(dim_, out_func_p_, out_func_log_p_), connr(connr_), con_select(new real[n_con])
  { for (int i=0; i<n_con; i++) con_select[i]=0;
    con_select[connr]=1;
    sparsity=sparsity_;
  }

  double eval(const UserVector<double>& x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error evaluating constraint " << connr << ": " << con_name(connr) << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
                char* str=new char[200]; sprintf(str, "ASL-error evaluating constraint %i: %s", connr, con_name(connr));
            write_sol(str, (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
  }
        return conival(connr, (double*)(const Pointer<double>)x, NULL);
  }

  void grad(dvector &g, const dvector &x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error computing gradient of constraint " << connr << ": " << con_name(connr) << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
                char* str=new char[200]; sprintf(str, "ASL-error computing gradient of constraint %i: %s", connr, con_name(connr));
            write_sol(str, (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
          }
    congrd(connr, (double*)(const Pointer<double>)x, (double*)(Pointer<double>)g, NULL);
  }

  void grad(UserVector<double>& g, const UserVector<double>& x) const {
        delete asl->i.err_jmp_;
        asl->i.err_jmp_=new Jmp_buf;
          if (setjmp(asl->i.err_jmp_->jb)) {
                out_log << "ASL-error computing gradient of constraint " << connr << ": " << con_name(connr) << endl;
                out_log << "Last point: " << endl;
                for (int i=0; i<x.dim(); i++) out_log << var_name(i) << ": " << x(i) << endl;
                char* str=new char[200]; sprintf(str, "ASL-error computing gradient of constraint %i: %s", connr, con_name(connr));
            write_sol(str, (double*)(const Pointer<double>)x, NULL, NULL);
                exit(0);
          }
    double* gr=new double[g.size()];
    congrd(connr, (double*)(const Pointer<double>)x, gr, NULL);
    g.set(gr, g.dim());
    delete gr;
  }
        
        using Func::grad;

  void HessMult(dvector& y, const dvector& x, const dvector& z) const {
    eval(x);
    hvcomp((double*)(Pointer<double>)y, (double*)(const Pointer<double>)z, -1, NULL, con_select);
  }

  void HessMult(UserVector<double>& y, const UserVector<double>& x, const UserVector<double>& z) const {
    eval(x);
    double* y0=new double[y.size()];
    hvcomp(y0, (double*)(const Pointer<double>)z, -1, NULL, con_select);
    y.set(y0, y.dim());
    delete y0;
  }
        
        using Func::HessMult;

        void set_curvature(CurvatureType ct) { curv_type=ct; };
        CurvatureType get_curvature() const { return curv_type; };
        
  void print(ostream& out) const {
    out << "amplCon " << connr << ": dim=" << dim() << ": " << con_name(connr) << endl;
  }
};


#endif // COIN_HAS_ASL
#endif // AMPL_H

---