ascend4/solver/conopt.c

/*
 *  Definitions of CONOPT Subroutines
 *  by Vicente Rico-Ramirez
 *  Created: 07/97
 *  Version: $Revision: 1.5 $
 *  Version control file: $RCSfile: conopt.c,v $
 *  Date last modified: $Date: 1998/02/27 14:33:23 $
 *  Last modified by: $Author: mthomas $
 *  
 *  This file is part of the SLV solver.
 *  
 *  The SLV solver is free software; you can redistribute
 *  it and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *  
 *  The SLV solver is distributed in hope that it will be
 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software Foundation,
 *  Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check the file named
 *  COPYING.  COPYING is found in ../compiler.
 *
 */

#include "utilities/ascConfig.h"
#include "solver/conopt.h"
#if defined(DYNAMIC_CONOPT)
#include "utilities/ascDynaLoad.h"
#include "solver/conoptdll.h"
#endif

/*
 * is CONOPT available ?
 */
#if (defined(STATIC_CONOPT) || defined(DYNAMIC_CONOPT))
#define CONOPT_ACTIVE TRUE
#else   /* defined(STATIC_CONOPT) */
#define CONOPT_ACTIVE FALSE
#endif /* defined(STATIC_CONOPT) */

#if CONOPT_ACTIVE  /* code used if CONOPT is available */

/*
 *  Optimization subroutines for CONOPT
 *  ---------------------------------
 */

/*
 *  User-defined subroutines
 *  ------------------------
 */

/*
 * COIRMS Based on the information provided in Coispz, CONOPT will
 * allocate the number of vectors into which the user can define
 * the details of the model. The details of the model are defined
 * here.
 *
 * COIRMS(lower, curr, upper, vsta, type,rhs, fv, esta, colsta,
 * rowno, value, nlflag, n, m, n1, nz, usrmem)
 *
 * lower - lower bounds on the variables
 * curr  - intial values of the variables
 * upper - upper bounds on the variables
 * vsta  - initial status of the variable(o nonbasic, 1 basic)
 * type  - types of equations (0 equality,1 greater,2 less)
 * rhs   - values of the right hand sides
 * fv    - sum of the nonlinear terms in the initial point
 * esta  - initial status of the slack in the constraint (nonbasic,basic)
 * colsta- start of column pointers
 * rowno - row or equation numbers of the nonzeros
 * value - values of the jacobian elements
 * nlflag- nonlinearity flags(0 nonzero constant,1 varying)
 * n     - number of variables
 * m     - number of constraints
 * n1    - n+1
 * nz    - number of jacobian elements
 * usrmem- user memory defined by conopt 
 */
void COIRMS(real64 *lower, real64 *curr, real64 *upper, int32 *vsta, 
        int32 *type, real64 *rhs, real64 *fv, int32 *esta, int32 *colsta,
        int32 *rowno, real64 *value, int32 *nlflag, int32 *n, int32 *m,
        int32 *n1, int32 *nz, real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem; 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coirms_ptr == NULL) {
    return;
  }
  conopt_ptrs->coirms_ptr(lower, curr, upper, vsta, type, rhs, fv, esta, 
              colsta, rowno, value, nlflag, n, m, n1, nz, 
              usr_mem[1]);
}


/*
 * COIFBL Defines the nonlinearities of the model by returning
 * numerical values. It works on a block of rows during each call.
 * COIFBL( x, g, otn, nto, from, to, jac, stcl, rnum, cnum, nl, strw,
 *         llen, indx, mode, errcnt, n, m, n1, m1, nz, usrmem)
 *
 * x     - punt of evaluation provided by conopt
 * g     - vector of function values
 * otn   - old to new permutation vector
 * nto   - new to old permutation vector
 * from  - range in permutation
 * to    - range in permutation
 * jac   - vector of jacobian values.
 *         The following are vectors defining the jacobian structure
 * stcl  - start of column pointers
 * rnum  - row numbers
 * cnum  - column numbers
 * nl    - nonlinearity flags
 * strw  - start row pointers
 * llen  - count of linear jacobian elements
 * indx  - pointers from the row-wise representation
 * mode  - indicator of mode of evaluation
 * errcnt- number of function evaluation errors
 * n     - umber of variables
 * m     - number of constraints
 * n1    - n+1
 * m1    - m+1
 * nz    - number of jacobian elements
 * usrmem- user memory defined by conopt 
 */
void COIFBL(real64 *x, real64 *g, int32 *otn, int32 *nto, int32 *from, 
        int32 *to, real64 *jac, int32 *stcl, int32 *rnum, int32 *cnum, 
        int32 *nl, int32 *strw, int32 *llen, int32 *indx, int32 *mode, 
        int32 *errcnt, int32 *n, int32 *m, int32 *n1, int32 *m1, 
        int32 *nz, real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem; 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coifbl_ptr == NULL) {
    return;
  }
  conopt_ptrs->coifbl_ptr(x, g, otn, nto, from, to, jac, stcl, rnum, cnum, 
              nl, strw, llen, indx, mode, errcnt, n, m, n1, m1, 
              nz, usr_mem[1]);

}

/*
 * COIFDE Defines the nonlinearities of the model by returning
 * numerical values. It works on one row or equation at a time
 * COIFDE(x, g, jac, rowno, jcnm, mode, errcnt, newpt, n, nj, usrmem)
 *
 * x      - punt of evaluation provided by conopt
 * g      - function value
 * jac    - jacobian values
 * rowno  - number of the row for which nonlinearities will be eval
 * jcnm   - list of column number fon the NL nonzeros
 * mode   - indicator of mode of evaluation
 * errcnt - sum of number of func evaluation errors thus far
 * newpt  - new point indicator
 * nj     - number of nonlinear nonzero jacobian elements
 * n      - number of variables
 * usrmem - user memory
 */
void COIFDE(real64 *x, real64 *g, real64 *jac, int32 *rowno, int32 *jcnm,
        int32 *mode, int32 *errcnt, int32 *newpt, int32 *n, int32 *nj,
        real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coifde_ptr == NULL) {
    return;
  }
  conopt_ptrs->coifde_ptr(x, g, jac, rowno, jcnm, mode, errcnt, newpt, n, 
              nj, usr_mem[1]);
}


/*
 * COISTA Pass the solution from CONOPT to the modeler. It returns
 * completion status
 * COISTA(modsta, solsts, iter, objval, usrmem)
 *
 * modsta - model status
 * solsta - solver status
 * iter   - number of iterations
 * objval - objective value
 * usrmem - user memory
 */
void COISTA(int32 *modsta, int32 *solsta, int32 *iter, real64 *objval,
        real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coista_ptr == NULL) {
    return;
  }
  conopt_ptrs->coista_ptr(modsta, solsta, iter, objval, usr_mem[1]);
}


/*
 * COIRS passes the solution from CONOPT to the modeler. It returns
 * solution values
 * COIRS(val, xmar, xbas, xsta, yval, ymar, ybas, ysta, n, m, usrmem)
 *
 * xval   - the solution values of the variables
 * xmar   - corresponding marginal values
 * xbas   - basis indicator for column (at bound, basic, nonbasic)
 * xsta   - status of column (normal, nonoptimal, infeasible,unbounded)
 * yval   - values of the left hand side in all the rows
 * ymar   - corresponding marginal values
 * ybas   - basis indicator for row
 * ysta   - status of row
 * n      - number of variables
 * m      - number of constraints
 * usrmem - user memory
 */
void COIRS(real64 *xval, real64 *xmar, int32 *xbas, int32 *xsta, real64 *yval,
       real64 *ymar, int32 *ybas, int32 * ysta, int32 *n, int32 *m,
       real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coirs_ptr == NULL) {
    return;
  }
  conopt_ptrs->coirs_ptr(xval, xmar, xbas, xsta, yval, ymar, ybas, ysta, 
             n, m, usr_mem[1]);
}


/*
 * COIUSZ communicates and update of an existing model to CONOPT
 * COIUSZ(nintg, ipsz, nreal, rpsz, usrmem)
 *
 * nintg - number of positions in ipsz
 * ipsz  - array describing problem size and options
 * nreal - number of positions in rpsz
 * rpsz  - array of reals describing problem size and options
 * usrmem- user memory
 */
void COIUSZ(int32 *nintg, int32 *ipsz, int32 *nreal, real64 *rpsz, 
        real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coiusz_ptr == NULL) {
    return;
  }
  conopt_ptrs->coiusz_ptr(nintg, ipsz, nreal, rpsz, usr_mem[1]);
}


/*
 * COIOPT communicates non-default option values to CONOPT
 * COIOPT(name, rval, ival, lval, usrmem)
 * name   - the name of a CONOPT CR-cell defined by the modeler
 * rval   - the value to be assigned to name if the cells contains a real
 * ival   - the value to be assigned to name if the cells contains an int
 * lval   - the value to be assigned to name if the cells contains a log value
 * usrmem - user memory
 */
void COIOPT(char *name, real64 *rval, int32 *ival, int32 *logical, 
        real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coiopt_ptr == NULL) {
    return;
  }
  conopt_ptrs->coiopt_ptr(name, rval, ival, logical, usr_mem[1]);
}


/*
 * COIPSZ communicates the model size and structure to CONOPT
 * COIPSZ(nintgr, ipsz, nreal, rpsz, usrmem)
 *
 * ningtr - number of positions in ipsz
 * ipsz   - array describing problem size and options
 * nreal  - number of positions in rpsz
 * rpsz   - array of reals describing problem size and options
 * usrmem - user memory
 */
void COIPSZ(int32 *nintgr, int32 *ipsz, int32 *nreal, real64 *rpsz, 
        real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coipsz_ptr == NULL) {
    return;
  }
  conopt_ptrs->coipsz_ptr(nintgr, ipsz, nreal, rpsz, usr_mem[1]);
}


extern void COIMSG (int32 *nmsg, int32 *smsg, int32 *llen,
      char msgv[80*15],real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coimsg_ptr == NULL) {
    return;
  }
  conopt_ptrs->coimsg_ptr(nmsg, smsg, llen, msgv, usr_mem[1]);
}

extern void COISCR (char msg[80], int32 *len)
{
  FPRINTF(stdout,"%.*s\n",*len,&msg[0]);
}

extern void COIEC (int32 *colno, int32 *msglen, char msg[80],real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coiec_ptr == NULL) {
    return;
  }
  conopt_ptrs->coiec_ptr(colno, msglen, msg, usr_mem[1]);
}

extern void COIER (int32 *rowno, int32 *msglen, char msg[80],real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coier_ptr == NULL) {
    return;
  }
  conopt_ptrs->coier_ptr(rowno, msglen, msg, usr_mem[1]);
}

extern void COIENZ (int32 *colno, int32 *rowno, int32 *posno,
      int32 *msglen, char msg[80],real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coienz_ptr == NULL) {
    return;
  }
  conopt_ptrs->coienz_ptr(colno, rowno, posno, msglen, msg, usr_mem[1]);
}

extern void COIPRG (int32 *nintgr, int32 *intrep, int32 *nreal,
      real64 *rl, real64 *x, real64 *usrmem, int32 *finish)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coiprg_ptr == NULL) {
    return;
  }
  conopt_ptrs->coiprg_ptr(nintgr, intrep, nreal, rl, x, usr_mem[1], finish);
}

extern void COIORC (int32 *colno, int32 *rowno, real64 *value,
      real64 *resid,real64 *usrmem)
{
  conopt_pointers conopt_ptrs;
  real64 **usr_mem;

  usr_mem = (real64 **)usrmem;
 
  conopt_ptrs = (conopt_pointers)usr_mem[0];
  if (conopt_ptrs->coiorc_ptr == NULL) {
    return;
  }
  conopt_ptrs->coiorc_ptr(colno, rowno, value, resid, usr_mem[1]);
}

#if defined(DYNAMIC_CONOPT)
REGISTER_CONOPT_FUNCTION_FUNC *register_conopt_function;
UNREGISTER_CONOPT_FUNCTION_FUNC *unregister_conopt_function;
COICRM_FUNC *COICRM;
COICSM_FUNC *COICSM;
COIMEM_FUNC *COIMEM;
#endif /* DYNAMIC_CONOPT */

/*
 *  Provided subroutines coicsm and coimem
 *  --------------------------------------
 */
/*
 * IMPORTANT: The use of the following functions is a   H A C K   to aovid
 * unresolved externals while linking to the CONOPT library. For some
 * reason, the linker wants the calls to the provided subroutines 
 * COICSM and COIMEM in the same file as the definition of the user 
 * defined CONOPT subroutines
 */
/* 
 * Memory estimation by using CONOPT subroutine coimem
 *
 * COIMEM Estimates the amount of memory needed by CONOPT
 * COIMEM(nintgr, ipsz, minmem, estmem)
 *
 * nintgr   - number of elements in the array ipsz. Should be 3.
 * ipsz     - vector of integers to describe the size of the model
 * minmem   - Minimum estimate for the memory needed. Measured in
 *            number of real elements of work
 * estmem   - Estimate of the amount of memory
 */
void conopt_estimate_memory(int32 *nintgr, int32 *ipsz, int32 *minmem,
                int32 *estmem)
{
  COIMEM(nintgr, ipsz, minmem, estmem);
}


/*
 * COICRM restarts CONOPT with user memory
 * COICRM(kept, usrmem, lwork, work, maxusd, curusd)
 *
 * kept   - Whether CONOPT has kept the model after solving it or not
 * usrmem - array passed to all subroutines. If not needed is dummy array
 * lwork  - lenght of working array work
 * work   - working array supplied by the user
 * maxusd - maximum amount of memory in work used during optimization
 * curusd - current amount of memory in use
 */
void conopt_restart(int32 *kept, real64 **usrmem, int32 *lwork, real64 *work, 
            int32 *maxusd, int32 *curusd)
{ 
  real64 *usr_mem;
  usr_mem = (real64 *)usrmem;

  FPRINTF(ASCERR,"\n");
  FPRINTF(ASCERR,"Restarting Conopt\n");
  FPRINTF(ASCERR,"\n");

  COICRM(kept, usr_mem, lwork, work, maxusd,curusd);
}


/*
 * COICSM starts up CONOPT with user memory
 * COICSM(kept, usrmem, lwork, work, maxusd, curusd)
 *
 * kept   - Whether CONOPT has kept the model after solving it or not
 * usrmem - array passed to all subroutines. If not needed is dummy array
 * lwork  - lenght of working array work
 * work   - working array supplied by the user
 * maxusd - maximum amount of memory in work used during optimization
 * curusd - current amount of memory in use
 */
void conopt_start(int32 *kept, real64 **usrmem, int32 *lwork, real64 *work, 
          int32 *maxusd, int32 *curusd)
{ 
  conopt_pointers conopt_ptrs;
  real64 *usr_mem;
  usr_mem = (real64 *)usrmem;

  FPRINTF(ASCERR,"\n");
  FPRINTF(ASCERR,"Starting Conopt\n");
  FPRINTF(ASCERR,"\n");

#if defined(DYNAMIC_CONOPT)
  conopt_ptrs = (conopt_pointers)usrmem[0];
  
  register_conopt_function(COIRMS_ENUM,
    conopt_ptrs->coirms_ptr == NULL ? NULL : (void *)COIRMS);
  register_conopt_function(COIFBL_ENUM,
    conopt_ptrs->coifbl_ptr == NULL ? NULL : (void *)COIFBL);
  register_conopt_function(COIFDE_ENUM,
    conopt_ptrs->coifde_ptr == NULL ? NULL : (void *)COIFDE);
  register_conopt_function(COIRS_ENUM,
    conopt_ptrs->coirs_ptr == NULL ? NULL : (void *)COIRS);
  register_conopt_function(COISTA_ENUM,
    conopt_ptrs->coista_ptr == NULL ? NULL : (void *)COISTA);
  register_conopt_function(COIUSZ_ENUM,
    conopt_ptrs->coiusz_ptr == NULL ? NULL : (void *)COIUSZ);
  register_conopt_function(COIOPT_ENUM,
    conopt_ptrs->coiopt_ptr == NULL ? NULL : (void *)COIOPT);
  register_conopt_function(COIPSZ_ENUM,
    conopt_ptrs->coipsz_ptr == NULL ? NULL : (void *)COIPSZ);

  register_conopt_function(COIMSG_ENUM,
    conopt_ptrs->coimsg_ptr == NULL ? NULL : (void *)COIMSG);
  register_conopt_function(COISCR_ENUM,(void *)COISCR);
  register_conopt_function(COIEC_ENUM,
    conopt_ptrs->coiec_ptr == NULL ? NULL : (void *)COIEC);
  register_conopt_function(COIER_ENUM,
    conopt_ptrs->coier_ptr == NULL ? NULL : (void *)COIER);
  register_conopt_function(COIENZ_ENUM,
    conopt_ptrs->coienz_ptr == NULL ? NULL : (void *)COIENZ);
  register_conopt_function(COIPRG_ENUM,
    conopt_ptrs->coiprg_ptr == NULL ? NULL : (void *)COIPRG);
  register_conopt_function(COIORC_ENUM,
    conopt_ptrs->coiorc_ptr == NULL ? NULL : (void *)COIORC);

#endif /* DYNAMIC_CONOPT */
  COICSM(kept, usr_mem, lwork, work, maxusd,curusd);
}
#if defined(DYNAMIC_CONOPT)
int32 conopt_loaded = 1;

int32 conopt_load(void) {
  int32 status;
  if (conopt_loaded == 0) {
    return 0; /* allready loaded */
  }
  status = Asc_DynamicLoad("dllcnsub.dll", NULL);
  if (status != 0) {
    return 1; /* failure */
  }
  register_conopt_function =
    (REGISTER_CONOPT_FUNCTION_FUNC *)Asc_DynamicSymbol("dllcnsub.dll",
    "register_conopt_function");
  unregister_conopt_function =
    (UNREGISTER_CONOPT_FUNCTION_FUNC *)Asc_DynamicSymbol("dllcnsub.dll",
    "unregister_conopt_function");
  COICRM = (COICRM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COICRM");
  COICSM = (COICSM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COICSM");
  COIMEM = (COIMEM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COIMEM");
  if (register_conopt_function == NULL ||
    unregister_conopt_function == NULL ||
    COICRM == NULL ||
    COICSM == NULL ||
    COIMEM == NULL) {
    return 1; /* failure */
  }
  conopt_loaded = 0;
  return 0;
}
#endif /* DYNAMIC_CONOPT */
#endif /* CONOPT_ACTIVE */
1	aw0a	1	/*
2			* Definitions of CONOPT Subroutines
3			* by Vicente Rico-Ramirez
4			* Created: 07/97
5			* Version: $Revision: 1.5 $
6			* Version control file: $RCSfile: conopt.c,v $
7			* Date last modified: $Date: 1998/02/27 14:33:23 $
8			* Last modified by: $Author: mthomas $
9			*
10			* This file is part of the SLV solver.
11			*
12			* The SLV solver is free software; you can redistribute
13			* it and/or modify it under the terms of the GNU General Public License as
14			* published by the Free Software Foundation; either version 2 of the
15			* License, or (at your option) any later version.
16			*
17			* The SLV solver is distributed in hope that it will be
18			* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
19			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20			* General Public License for more details.
21			*
22			* You should have received a copy of the GNU General Public License
23			* along with the program; if not, write to the Free Software Foundation,
24			* Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
25			* COPYING. COPYING is found in ../compiler.
26			*
27			*/
28
29			#include "utilities/ascConfig.h"
30			#include "solver/conopt.h"
31			#if defined(DYNAMIC_CONOPT)
32			#include "utilities/ascDynaLoad.h"
33			#include "solver/conoptdll.h"
34			#endif
35
36			/*
37			* is CONOPT available ?
38			*/
39			#if (defined(STATIC_CONOPT) \|\| defined(DYNAMIC_CONOPT))
40			#define CONOPT_ACTIVE TRUE
41			#else /* defined(STATIC_CONOPT) */
42			#define CONOPT_ACTIVE FALSE
43			#endif /* defined(STATIC_CONOPT) */
44
45			#if CONOPT_ACTIVE /* code used if CONOPT is available */
46
47			/*
48			* Optimization subroutines for CONOPT
49			* ---------------------------------
50			*/
51
52			/*
53			* User-defined subroutines
54			* ------------------------
55			*/
56
57			/*
58			* COIRMS Based on the information provided in Coispz, CONOPT will
59			* allocate the number of vectors into which the user can define
60			* the details of the model. The details of the model are defined
61			* here.
62			*
63			* COIRMS(lower, curr, upper, vsta, type,rhs, fv, esta, colsta,
64			* rowno, value, nlflag, n, m, n1, nz, usrmem)
65			*
66			* lower - lower bounds on the variables
67			* curr - intial values of the variables
68			* upper - upper bounds on the variables
69			* vsta - initial status of the variable(o nonbasic, 1 basic)
70			* type - types of equations (0 equality,1 greater,2 less)
71			* rhs - values of the right hand sides
72			* fv - sum of the nonlinear terms in the initial point
73			* esta - initial status of the slack in the constraint (nonbasic,basic)
74			* colsta- start of column pointers
75			* rowno - row or equation numbers of the nonzeros
76			* value - values of the jacobian elements
77			* nlflag- nonlinearity flags(0 nonzero constant,1 varying)
78			* n - number of variables
79			* m - number of constraints
80			* n1 - n+1
81			* nz - number of jacobian elements
82			* usrmem- user memory defined by conopt
83			*/
84			void COIRMS(real64 lower, real64 curr, real64 upper, int32 vsta,
85			int32 type, real64 rhs, real64 fv, int32 esta, int32 *colsta,
86			int32 rowno, real64 value, int32 nlflag, int32 n, int32 *m,
87			int32 n1, int32 nz, real64 *usrmem)
88			{
89			conopt_pointers conopt_ptrs;
90			real64 **usr_mem;
91
92			usr_mem = (real64 **)usrmem;
93			conopt_ptrs = (conopt_pointers)usr_mem[0];
94			if (conopt_ptrs->coirms_ptr == NULL) {
95			return;
96			}
97			conopt_ptrs->coirms_ptr(lower, curr, upper, vsta, type, rhs, fv, esta,
98			colsta, rowno, value, nlflag, n, m, n1, nz,
99			usr_mem[1]);
100			}
101
102
103			/*
104			* COIFBL Defines the nonlinearities of the model by returning
105			* numerical values. It works on a block of rows during each call.
106			* COIFBL( x, g, otn, nto, from, to, jac, stcl, rnum, cnum, nl, strw,
107			* llen, indx, mode, errcnt, n, m, n1, m1, nz, usrmem)
108			*
109			* x - punt of evaluation provided by conopt
110			* g - vector of function values
111			* otn - old to new permutation vector
112			* nto - new to old permutation vector
113			* from - range in permutation
114			* to - range in permutation
115			* jac - vector of jacobian values.
116			* The following are vectors defining the jacobian structure
117			* stcl - start of column pointers
118			* rnum - row numbers
119			* cnum - column numbers
120			* nl - nonlinearity flags
121			* strw - start row pointers
122			* llen - count of linear jacobian elements
123			* indx - pointers from the row-wise representation
124			* mode - indicator of mode of evaluation
125			* errcnt- number of function evaluation errors
126			* n - umber of variables
127			* m - number of constraints
128			* n1 - n+1
129			* m1 - m+1
130			* nz - number of jacobian elements
131			* usrmem- user memory defined by conopt
132			*/
133			void COIFBL(real64 x, real64 g, int32 otn, int32 nto, int32 *from,
134			int32 to, real64 jac, int32 stcl, int32 rnum, int32 *cnum,
135			int32 nl, int32 strw, int32 llen, int32 indx, int32 *mode,
136			int32 errcnt, int32 n, int32 m, int32 n1, int32 *m1,
137			int32 nz, real64 usrmem)
138			{
139			conopt_pointers conopt_ptrs;
140			real64 **usr_mem;
141
142			usr_mem = (real64 **)usrmem;
143			conopt_ptrs = (conopt_pointers)usr_mem[0];
144			if (conopt_ptrs->coifbl_ptr == NULL) {
145			return;
146			}
147			conopt_ptrs->coifbl_ptr(x, g, otn, nto, from, to, jac, stcl, rnum, cnum,
148			nl, strw, llen, indx, mode, errcnt, n, m, n1, m1,
149			nz, usr_mem[1]);
150
151			}
152
153			/*
154			* COIFDE Defines the nonlinearities of the model by returning
155			* numerical values. It works on one row or equation at a time
156			* COIFDE(x, g, jac, rowno, jcnm, mode, errcnt, newpt, n, nj, usrmem)
157			*
158			* x - punt of evaluation provided by conopt
159			* g - function value
160			* jac - jacobian values
161			* rowno - number of the row for which nonlinearities will be eval
162			* jcnm - list of column number fon the NL nonzeros
163			* mode - indicator of mode of evaluation
164			* errcnt - sum of number of func evaluation errors thus far
165			* newpt - new point indicator
166			* nj - number of nonlinear nonzero jacobian elements
167			* n - number of variables
168			* usrmem - user memory
169			*/
170			void COIFDE(real64 x, real64 g, real64 jac, int32 rowno, int32 *jcnm,
171			int32 mode, int32 errcnt, int32 newpt, int32 n, int32 *nj,
172			real64 *usrmem)
173			{
174			conopt_pointers conopt_ptrs;
175			real64 **usr_mem;
176
177			usr_mem = (real64 **)usrmem;
178
179			conopt_ptrs = (conopt_pointers)usr_mem[0];
180			if (conopt_ptrs->coifde_ptr == NULL) {
181			return;
182			}
183			conopt_ptrs->coifde_ptr(x, g, jac, rowno, jcnm, mode, errcnt, newpt, n,
184			nj, usr_mem[1]);
185			}
186
187
188
189			/*
190			* COISTA Pass the solution from CONOPT to the modeler. It returns
191			* completion status
192			* COISTA(modsta, solsts, iter, objval, usrmem)
193			*
194			* modsta - model status
195			* solsta - solver status
196			* iter - number of iterations
197			* objval - objective value
198			* usrmem - user memory
199			*/
200			void COISTA(int32 modsta, int32 solsta, int32 iter, real64 objval,
201			real64 *usrmem)
202			{
203			conopt_pointers conopt_ptrs;
204			real64 **usr_mem;
205
206			usr_mem = (real64 **)usrmem;
207
208			conopt_ptrs = (conopt_pointers)usr_mem[0];
209			if (conopt_ptrs->coista_ptr == NULL) {
210			return;
211			}
212			conopt_ptrs->coista_ptr(modsta, solsta, iter, objval, usr_mem[1]);
213			}
214
215
216			/*
217			* COIRS passes the solution from CONOPT to the modeler. It returns
218			* solution values
219			* COIRS(val, xmar, xbas, xsta, yval, ymar, ybas, ysta, n, m, usrmem)
220			*
221			* xval - the solution values of the variables
222			* xmar - corresponding marginal values
223			* xbas - basis indicator for column (at bound, basic, nonbasic)
224			* xsta - status of column (normal, nonoptimal, infeasible,unbounded)
225			* yval - values of the left hand side in all the rows
226			* ymar - corresponding marginal values
227			* ybas - basis indicator for row
228			* ysta - status of row
229			* n - number of variables
230			* m - number of constraints
231			* usrmem - user memory
232			*/
233			void COIRS(real64 xval, real64 xmar, int32 xbas, int32 xsta, real64 *yval,
234			real64 ymar, int32 ybas, int32 * ysta, int32 n, int32 m,
235			real64 *usrmem)
236			{
237			conopt_pointers conopt_ptrs;
238			real64 **usr_mem;
239
240			usr_mem = (real64 **)usrmem;
241
242			conopt_ptrs = (conopt_pointers)usr_mem[0];
243			if (conopt_ptrs->coirs_ptr == NULL) {
244			return;
245			}
246			conopt_ptrs->coirs_ptr(xval, xmar, xbas, xsta, yval, ymar, ybas, ysta,
247			n, m, usr_mem[1]);
248			}
249
250
251			/*
252			* COIUSZ communicates and update of an existing model to CONOPT
253			* COIUSZ(nintg, ipsz, nreal, rpsz, usrmem)
254			*
255			* nintg - number of positions in ipsz
256			* ipsz - array describing problem size and options
257			* nreal - number of positions in rpsz
258			* rpsz - array of reals describing problem size and options
259			* usrmem- user memory
260			*/
261			void COIUSZ(int32 nintg, int32 ipsz, int32 nreal, real64 rpsz,
262			real64 *usrmem)
263			{
264			conopt_pointers conopt_ptrs;
265			real64 **usr_mem;
266
267			usr_mem = (real64 **)usrmem;
268
269			conopt_ptrs = (conopt_pointers)usr_mem[0];
270			if (conopt_ptrs->coiusz_ptr == NULL) {
271			return;
272			}
273			conopt_ptrs->coiusz_ptr(nintg, ipsz, nreal, rpsz, usr_mem[1]);
274			}
275
276
277			/*
278			* COIOPT communicates non-default option values to CONOPT
279			* COIOPT(name, rval, ival, lval, usrmem)
280			* name - the name of a CONOPT CR-cell defined by the modeler
281			* rval - the value to be assigned to name if the cells contains a real
282			* ival - the value to be assigned to name if the cells contains an int
283			* lval - the value to be assigned to name if the cells contains a log value
284			* usrmem - user memory
285			*/
286			void COIOPT(char name, real64 rval, int32 ival, int32 logical,
287			real64 *usrmem)
288			{
289			conopt_pointers conopt_ptrs;
290			real64 **usr_mem;
291
292			usr_mem = (real64 **)usrmem;
293
294			conopt_ptrs = (conopt_pointers)usr_mem[0];
295			if (conopt_ptrs->coiopt_ptr == NULL) {
296			return;
297			}
298			conopt_ptrs->coiopt_ptr(name, rval, ival, logical, usr_mem[1]);
299			}
300
301
302			/*
303			* COIPSZ communicates the model size and structure to CONOPT
304			* COIPSZ(nintgr, ipsz, nreal, rpsz, usrmem)
305			*
306			* ningtr - number of positions in ipsz
307			* ipsz - array describing problem size and options
308			* nreal - number of positions in rpsz
309			* rpsz - array of reals describing problem size and options
310			* usrmem - user memory
311			*/
312			void COIPSZ(int32 nintgr, int32 ipsz, int32 nreal, real64 rpsz,
313			real64 *usrmem)
314			{
315			conopt_pointers conopt_ptrs;
316			real64 **usr_mem;
317
318			usr_mem = (real64 **)usrmem;
319
320			conopt_ptrs = (conopt_pointers)usr_mem[0];
321			if (conopt_ptrs->coipsz_ptr == NULL) {
322			return;
323			}
324			conopt_ptrs->coipsz_ptr(nintgr, ipsz, nreal, rpsz, usr_mem[1]);
325			}
326
327
328			extern void COIMSG (int32 nmsg, int32 smsg, int32 *llen,
329			char msgv[8015],real64 usrmem)
330			{
331			conopt_pointers conopt_ptrs;
332			real64 **usr_mem;
333
334			usr_mem = (real64 **)usrmem;
335
336			conopt_ptrs = (conopt_pointers)usr_mem[0];
337			if (conopt_ptrs->coimsg_ptr == NULL) {
338			return;
339			}
340			conopt_ptrs->coimsg_ptr(nmsg, smsg, llen, msgv, usr_mem[1]);
341			}
342
343			extern void COISCR (char msg[80], int32 *len)
344			{
345			FPRINTF(stdout,"%.s\n",len,&msg[0]);
346			}
347
348			extern void COIEC (int32 colno, int32 msglen, char msg[80],real64 *usrmem)
349			{
350			conopt_pointers conopt_ptrs;
351			real64 **usr_mem;
352
353			usr_mem = (real64 **)usrmem;
354
355			conopt_ptrs = (conopt_pointers)usr_mem[0];
356			if (conopt_ptrs->coiec_ptr == NULL) {
357			return;
358			}
359			conopt_ptrs->coiec_ptr(colno, msglen, msg, usr_mem[1]);
360			}
361
362			extern void COIER (int32 rowno, int32 msglen, char msg[80],real64 *usrmem)
363			{
364			conopt_pointers conopt_ptrs;
365			real64 **usr_mem;
366
367			usr_mem = (real64 **)usrmem;
368
369			conopt_ptrs = (conopt_pointers)usr_mem[0];
370			if (conopt_ptrs->coier_ptr == NULL) {
371			return;
372			}
373			conopt_ptrs->coier_ptr(rowno, msglen, msg, usr_mem[1]);
374			}
375
376			extern void COIENZ (int32 colno, int32 rowno, int32 *posno,
377			int32 msglen, char msg[80],real64 usrmem)
378			{
379			conopt_pointers conopt_ptrs;
380			real64 **usr_mem;
381
382			usr_mem = (real64 **)usrmem;
383
384			conopt_ptrs = (conopt_pointers)usr_mem[0];
385			if (conopt_ptrs->coienz_ptr == NULL) {
386			return;
387			}
388			conopt_ptrs->coienz_ptr(colno, rowno, posno, msglen, msg, usr_mem[1]);
389			}
390
391			extern void COIPRG (int32 nintgr, int32 intrep, int32 *nreal,
392			real64 rl, real64 x, real64 usrmem, int32 finish)
393			{
394			conopt_pointers conopt_ptrs;
395			real64 **usr_mem;
396
397			usr_mem = (real64 **)usrmem;
398
399			conopt_ptrs = (conopt_pointers)usr_mem[0];
400			if (conopt_ptrs->coiprg_ptr == NULL) {
401			return;
402			}
403			conopt_ptrs->coiprg_ptr(nintgr, intrep, nreal, rl, x, usr_mem[1], finish);
404			}
405
406			extern void COIORC (int32 colno, int32 rowno, real64 *value,
407			real64 resid,real64 usrmem)
408			{
409			conopt_pointers conopt_ptrs;
410			real64 **usr_mem;
411
412			usr_mem = (real64 **)usrmem;
413
414			conopt_ptrs = (conopt_pointers)usr_mem[0];
415			if (conopt_ptrs->coiorc_ptr == NULL) {
416			return;
417			}
418			conopt_ptrs->coiorc_ptr(colno, rowno, value, resid, usr_mem[1]);
419			}
420
421			#if defined(DYNAMIC_CONOPT)
422			REGISTER_CONOPT_FUNCTION_FUNC *register_conopt_function;
423			UNREGISTER_CONOPT_FUNCTION_FUNC *unregister_conopt_function;
424			COICRM_FUNC *COICRM;
425			COICSM_FUNC *COICSM;
426			COIMEM_FUNC *COIMEM;
427			#endif /* DYNAMIC_CONOPT */
428
429			/*
430			* Provided subroutines coicsm and coimem
431			* --------------------------------------
432			*/
433			/*
434			* IMPORTANT: The use of the following functions is a H A C K to aovid
435			* unresolved externals while linking to the CONOPT library. For some
436			* reason, the linker wants the calls to the provided subroutines
437			* COICSM and COIMEM in the same file as the definition of the user
438			* defined CONOPT subroutines
439			*/
440			/*
441			* Memory estimation by using CONOPT subroutine coimem
442			*
443			* COIMEM Estimates the amount of memory needed by CONOPT
444			* COIMEM(nintgr, ipsz, minmem, estmem)
445			*
446			* nintgr - number of elements in the array ipsz. Should be 3.
447			* ipsz - vector of integers to describe the size of the model
448			* minmem - Minimum estimate for the memory needed. Measured in
449			* number of real elements of work
450			* estmem - Estimate of the amount of memory
451			*/
452			void conopt_estimate_memory(int32 nintgr, int32 ipsz, int32 *minmem,
453			int32 *estmem)
454			{
455			COIMEM(nintgr, ipsz, minmem, estmem);
456			}
457
458
459			/*
460			* COICRM restarts CONOPT with user memory
461			* COICRM(kept, usrmem, lwork, work, maxusd, curusd)
462			*
463			* kept - Whether CONOPT has kept the model after solving it or not
464			* usrmem - array passed to all subroutines. If not needed is dummy array
465			* lwork - lenght of working array work
466			* work - working array supplied by the user
467			* maxusd - maximum amount of memory in work used during optimization
468			* curusd - current amount of memory in use
469			*/
470			void conopt_restart(int32 kept, real64 usrmem, int32 lwork, real64 *work,
471			int32 maxusd, int32 curusd)
472			{
473			real64 *usr_mem;
474			usr_mem = (real64 *)usrmem;
475
476			FPRINTF(ASCERR,"\n");
477			FPRINTF(ASCERR,"Restarting Conopt\n");
478			FPRINTF(ASCERR,"\n");
479
480			COICRM(kept, usr_mem, lwork, work, maxusd,curusd);
481			}
482
483
484			/*
485			* COICSM starts up CONOPT with user memory
486			* COICSM(kept, usrmem, lwork, work, maxusd, curusd)
487			*
488			* kept - Whether CONOPT has kept the model after solving it or not
489			* usrmem - array passed to all subroutines. If not needed is dummy array
490			* lwork - lenght of working array work
491			* work - working array supplied by the user
492			* maxusd - maximum amount of memory in work used during optimization
493			* curusd - current amount of memory in use
494			*/
495			void conopt_start(int32 kept, real64 usrmem, int32 lwork, real64 *work,
496			int32 maxusd, int32 curusd)
497			{
498			conopt_pointers conopt_ptrs;
499			real64 *usr_mem;
500			usr_mem = (real64 *)usrmem;
501
502			FPRINTF(ASCERR,"\n");
503			FPRINTF(ASCERR,"Starting Conopt\n");
504			FPRINTF(ASCERR,"\n");
505
506			#if defined(DYNAMIC_CONOPT)
507			conopt_ptrs = (conopt_pointers)usrmem[0];
508
509			register_conopt_function(COIRMS_ENUM,
510			conopt_ptrs->coirms_ptr == NULL ? NULL : (void *)COIRMS);
511			register_conopt_function(COIFBL_ENUM,
512			conopt_ptrs->coifbl_ptr == NULL ? NULL : (void *)COIFBL);
513			register_conopt_function(COIFDE_ENUM,
514			conopt_ptrs->coifde_ptr == NULL ? NULL : (void *)COIFDE);
515			register_conopt_function(COIRS_ENUM,
516			conopt_ptrs->coirs_ptr == NULL ? NULL : (void *)COIRS);
517			register_conopt_function(COISTA_ENUM,
518			conopt_ptrs->coista_ptr == NULL ? NULL : (void *)COISTA);
519			register_conopt_function(COIUSZ_ENUM,
520			conopt_ptrs->coiusz_ptr == NULL ? NULL : (void *)COIUSZ);
521			register_conopt_function(COIOPT_ENUM,
522			conopt_ptrs->coiopt_ptr == NULL ? NULL : (void *)COIOPT);
523			register_conopt_function(COIPSZ_ENUM,
524			conopt_ptrs->coipsz_ptr == NULL ? NULL : (void *)COIPSZ);
525
526			register_conopt_function(COIMSG_ENUM,
527			conopt_ptrs->coimsg_ptr == NULL ? NULL : (void *)COIMSG);
528			register_conopt_function(COISCR_ENUM,(void *)COISCR);
529			register_conopt_function(COIEC_ENUM,
530			conopt_ptrs->coiec_ptr == NULL ? NULL : (void *)COIEC);
531			register_conopt_function(COIER_ENUM,
532			conopt_ptrs->coier_ptr == NULL ? NULL : (void *)COIER);
533			register_conopt_function(COIENZ_ENUM,
534			conopt_ptrs->coienz_ptr == NULL ? NULL : (void *)COIENZ);
535			register_conopt_function(COIPRG_ENUM,
536			conopt_ptrs->coiprg_ptr == NULL ? NULL : (void *)COIPRG);
537			register_conopt_function(COIORC_ENUM,
538			conopt_ptrs->coiorc_ptr == NULL ? NULL : (void *)COIORC);
539
540			#endif /* DYNAMIC_CONOPT */
541			COICSM(kept, usr_mem, lwork, work, maxusd,curusd);
542			}
543			#if defined(DYNAMIC_CONOPT)
544			int32 conopt_loaded = 1;
545
546			int32 conopt_load(void) {
547			int32 status;
548			if (conopt_loaded == 0) {
549			return 0; /* allready loaded */
550			}
551			status = Asc_DynamicLoad("dllcnsub.dll", NULL);
552			if (status != 0) {
553			return 1; /* failure */
554			}
555			register_conopt_function =
556			(REGISTER_CONOPT_FUNCTION_FUNC *)Asc_DynamicSymbol("dllcnsub.dll",
557			"register_conopt_function");
558			unregister_conopt_function =
559			(UNREGISTER_CONOPT_FUNCTION_FUNC *)Asc_DynamicSymbol("dllcnsub.dll",
560			"unregister_conopt_function");
561			COICRM = (COICRM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COICRM");
562			COICSM = (COICSM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COICSM");
563			COIMEM = (COIMEM_FUNC *)Asc_DynamicSymbol("dllcnsub.dll","COIMEM");
564			if (register_conopt_function == NULL \|\|
565			unregister_conopt_function == NULL \|\|
566			COICRM == NULL \|\|
567			COICSM == NULL \|\|
568			COIMEM == NULL) {
569			return 1; /* failure */
570			}
571			conopt_loaded = 0;
572			return 0;
573			}
574			#endif /* DYNAMIC_CONOPT */
575			#endif /* CONOPT_ACTIVE */