undefexa.c

sqp程序包。用sqp算法实现非线性约束的优化求解

/* **************************************************************************** */
/*                                 user functions                               */
/* **************************************************************************** */
#include "o8para.h"

main() {
    void donlp2(void);
    
    donlp2();
    
    exit(0);
}

/* **************************************************************************** */
/*                              donlp2 standard setup                           */
/* **************************************************************************** */
void setup0(void) {
    #define  X extern
    #include "o8comm.h"
    #undef   X
    
    static INTEGER i,j,nuser = 2;
    static DOUBLE  xst0[] = {0., /* not used : index 0 */
                             1.e0,1.e0};
                             
    /* name is ident of the example/user and can be set at users will           */
    /* the first static char [] must be alphabetic.  40 static char [s] maximum */

    strcpy(name,"undefexa");

    /*    x is initial guess and also holds the current solution */
    /*    problem dimension n = dim(x), nh = dim(h), ng = dim(g) */

    n      = nuser;
    nh     = 0;
    ng     = 4;
    analyt = TRUE;
    cold   = TRUE  ;
    silent = FALSE  ;
    epsdif = 1.e-8;

    /* del0 and tau0: see below */

    del0 = 1.e0;
    tau0 = 1.e0;
    for (i = 1 ; i <= n ; i++) {
        x[i] = xst0[i];
    }
    /* gunit-array, see donlp2doc.txt */
    
    for (j = 0 ; j <= 2 ; j++) {
        gunit[1][j] = -1;
        gunit[2][j] = 0;
        gunit[3][j] = 0;
    }
    gunit[1][3] = 1;
    gunit[2][3] = 1;
    gunit[3][3] = 1;
    gunit[1][4] = 1;
    gunit[2][4] = 2;
    gunit[3][4] = 1;
    
    /* gconst-array: */
    
    for (j = 0 ; j <= 2 ; j++) {
        gconst[j] = FALSE;
        
        /* if the j-th function is affine linear */
    }
    gconst[3] = TRUE;
    gconst[4] = TRUE;
    
    return;
}

/* **************************************************************************** */
/*                                 special setup                                */
/* **************************************************************************** */
void setup(void) {
    #define  X extern
    #include "o8comm.h"
    #undef   X
    
    /* change termination criterion */
    
    epsx = 1.e-10;
    
    /* change I/O-control */
    
    /* te2 = TRUE;  */
    
    /* now you get a detailed output, but no matrices */
    /* plus a long output in *.pro                    */
    
    return;
}

/* **************************************************************************** */
/*  the user may add additional computations using the computed solution here   */
/* **************************************************************************** */
void solchk(void) {
    #define  X extern
    #include "o8comm.h"
    #undef   X
    #include "o8cons.h"

    return;
}

/* **************************************************************************** */
/*                               objective function                             */
/* **************************************************************************** */
void ef(DOUBLE x[],DOUBLE *fx) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X
    ffuerr = FALSE ;
    icf = icf+1;
    if ( x[1]*x[2] <= .5e0 ) {
        ffuerr = TRUE;
        
        return;
    }
    *fx = -exp(x[1]*x[2]-1.e0)/(x[1]*x[2]-0.5e0);
    
    return;
}

/* **************************************************************************** */
/*                          gradient of objective function                      */
/* **************************************************************************** */
void egradf(DOUBLE x[],DOUBLE gradf[]) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X
    ffuerr = FALSE ;
    if ( x[1]*x[2] <= 0.5e0 ) {
      ffuerr = TRUE ;
      return ;
    }
    icgf = icgf+1;
    
    gradf[1] = -exp(x[1]*x[2]-1.e0)*(1.e0-1.e0/(x[1]*x[2]-0.5e0))
               *x[2]/(x[1]*x[2]-0.5e0);
    gradf[2] = -exp(x[1]*x[2]-1.e0)*(1.e0-1.e0/(x[1]*x[2]-0.5e0))
               *x[1]/(x[1]*x[2]-0.5e0);
               
    return;
}

/* **************************************************************************** */
/*                compute the i-th equality constaint, value is hxi             */
/* **************************************************************************** */
void eh(INTEGER i,DOUBLE x[],DOUBLE *hxi) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X
    
    return;
}

/* **************************************************************************** */
/*              compute the gradient of the i-th equality constraint            */
/* **************************************************************************** */
void egradh(INTEGER i,DOUBLE x[],DOUBLE gradhi[]) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X

    if ( gunit[1][i] != 1 ) cgres[i] = cgres[i]+1;
    
    return;
}

/* **************************************************************************** */
/*              compute the i-th inequality constaint, bounds included          */
/* **************************************************************************** */
void eg(INTEGER i,DOUBLE x[],DOUBLE *gxi) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X
    
    if ( gunit[1][i+nh] == -1 ) cres[i+nh] = cres[i+nh]+1;
    
    switch (i) {
    case 1:
        *gxi = x[1]*x[2]-0.75e0;
        
        return;
        
    case 2:
        *gxi = -pow(x[2],2)+2.e0-x[1];
        
        return;
        
    case 3:
        *gxi = x[1];
        
        return;
        
    case 4:

        *gxi = x[2];
        
        return;
    }
}

/* **************************************************************************** */
/*              compute the gradient of the i-th inequality constraint          */
/*          not necessary for bounds, but constant gradients must be set        */
/*                      here e.g. using dcopy from a data-field                 */
/* **************************************************************************** */
void egradg(INTEGER i,DOUBLE x[],DOUBLE gradgi[]) {
    #define  X extern
    #include "o8fuco.h"
    #undef   X
    
    static INTEGER j;

    if ( gunit[1][i+nh] != 1 ) cgres[i+nh] = cgres[i+nh]+1;
    
    for (j = 1 ; j <= NX ; j++) {
        gradgi[j] = 0.e0;
    }
    switch (i) {
    case 1:
        gradgi[1] = x[2];
        gradgi[2] = x[1];
        
        return;
        
    case 2:
        gradgi[1] = -1.e0;
        gradgi[2] = -2.e0*x[2];
        
        return;
    }
}

/* **************************************************************************** */
/*                        user functions (if bloc == TRUE)                      */
/* **************************************************************************** */
void eval_extern(INTEGER mode) {
    #define  X extern
    #include "o8comm.h"
    #include "o8fint.h"
    #undef   X
    #include "o8cons.h"

    return;
}