diff options
Diffstat (limited to 'thirdparty/linux/include/coin/ThirdParty/funcadd.h')
| -rw-r--r-- | thirdparty/linux/include/coin/ThirdParty/funcadd.h | 487 |
1 files changed, 487 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/ThirdParty/funcadd.h b/thirdparty/linux/include/coin/ThirdParty/funcadd.h new file mode 100644 index 0000000..ec30d97 --- /dev/null +++ b/thirdparty/linux/include/coin/ThirdParty/funcadd.h @@ -0,0 +1,487 @@ +/**************************************************************** +Copyright (C) 1997-2001 Lucent Technologies +All Rights Reserved + +Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby +granted, provided that the above copyright notice appear in all +copies and that both that the copyright notice and this +permission notice and warranty disclaimer appear in supporting +documentation, and that the name of Lucent or any of its entities +not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. +IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY +SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER +IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. +****************************************************************/ + +#ifndef FUNCADD_H_INCLUDED +#define FUNCADD_H_INCLUDED +#include "stdio1.h" /* for ANSI and any printing */ + +#ifndef VA_LIST +#define VA_LIST va_list +#endif + +#ifdef _WIN32 +#define Stdio_redefs +#endif + + typedef struct cryptblock cryptblock; + +#ifdef __cplusplus +#undef KR_headers +extern "C" { +#endif + +#ifndef real +typedef double real; +#endif +typedef struct arglist arglist; +typedef struct function function; +typedef struct TVA TVA; +typedef struct AmplExports AmplExports; +typedef struct AuxInfo AuxInfo; +typedef struct TableInfo TableInfo; +typedef struct TMInfo TMInfo; + +#ifndef No_arglist_def + +#undef Const +#ifdef KR_headers +#define Const /* nothing */ +#else +#define Const const +#endif + + struct +arglist { /* Information sent to user-defined functions */ + int n; /* number of args */ + int nr; /* number of real input args */ + int *at; /* argument types -- see DISCUSSION below */ + real *ra; /* pure real args (IN, OUT, and INOUT) */ + Const char **sa; /* symbolic IN args */ + real *derivs; /* for partial derivatives (if nonzero) */ + real *hes; /* for second partials (if nonzero) */ + char *dig; /* if (dig && dig[i]) { partials w.r.t. */ + /* ra[i] will not be used } */ + Char *funcinfo; /* for use by the function (if desired) */ + AmplExports *AE; /* functions made visible (via #defines below) */ + function *f; /* for internal use by AMPL */ + TVA *tva; /* for internal use by AMPL */ + char *Errmsg; /* To indicate an error, set this to a */ + /* description of the error. When derivs */ + /* is nonzero and the error is that first */ + /* derivatives cannot or are not computed, */ + /* a single quote character (') should be */ + /* the first character in the text assigned */ + /* to Errmsg, followed by the actual error */ + /* message. Similarly, if hes is nonzero */ + /* and the error is that second derivatives */ + /* are not or cannot be computed, a double */ + /* quote character (") should be the first */ + /* character in Errmsg, followed by the */ + /* actual error message text. */ + TMInfo *TMI; /* used in Tempmem calls */ + Char *Private; + /* The following fields are relevant */ + /* only when imported functions are called */ + /* by AMPL commands (not declarations). */ + + int nin; /* number of input (IN and INOUT) args */ + int nout; /* number of output (OUT and INOUT) args */ + int nsin; /* number of symbolic input arguments */ + int nsout; /* number of symbolic OUT and INOUT args */ + }; + +typedef real (*rfunc) ANSI((arglist *)); +typedef real (ufunc) ANSI((arglist *)); + +#endif /* No_arglist_def */ + + enum AMPLFUNC_AT_BITS { /* Intrepretation of at[i] when the type */ + /* arg to addfunc has the */ + /* FUNCADD_OUTPUT_ARGS bit on.*/ + AMPLFUNC_INARG = 1, /* IN or INOUT */ + AMPLFUNC_OUTARG = 2, /* OUT or INOUT */ + AMPLFUNC_STRING = 4, /* Input value is a string (sa[i]) */ + AMPLFUNC_STROUT = 8 /* String output value allowed */ + }; + + enum FUNCADD_TYPE { /* bits in "type" arg to addfunc */ + + /* The type arg to addfunc should consist of one of the */ + /* following values ... */ + + FUNCADD_REAL_VALUED = 0, /* real (double) valued function */ + FUNCADD_STRING_VALUED = 2, /* char* valued function (AMPL only) */ + FUNCADD_RANDOM_VALUED = 4, /* real random valued */ + FUNCADD_012ARGS = 6, /* Special case: real random valued */ + /* with 0 <= nargs <= 2 arguments */ + /* passed directly, rather than in */ + /* an arglist structure (AMPL only). */ + + /* possibly or-ed with the following... */ + + FUNCADD_STRING_ARGS = 1, /* allow string args */ + FUNCADD_OUTPUT_ARGS = 16, /* allow output args (AMPL only) */ + FUNCADD_TUPLE_VALUED = 32, /* not yet allowed */ + + /* internal use */ + FUNCADD_NO_ARGLIST = 8, + FUNCADD_NO_DUPWARN = 64, /* no complaint if already defined */ + FUNCADD_NONRAND_BUILTIN = 128 /* mean, variance, moment, etc. */ + }; + +/* If a constraint involves an imported function and presolve fixes all + * the arguments of the function, AMPL may later need to ask the + * function for its partial derivatives -- even though the solver had + * no reason to call the function. If so, it will pass an arglist *al + * with al->derivs nonzero, and it will expect the function to set + * al->derivs[i] to the partial derivative of the function with respect + * to al->ra[i]. Solvers that need to evaluate an imported function + * work the same way -- they set al->derivs to a nonzero value if they + * require both the function value and its first derivatives. Solvers + * that expect Hessians to be supplied to them also set al->hes to a + * nonzero value if they require second derivatives at the current + * argument. In this case, the function should set + * al->hes[i + j*(j+1)/2] to the partial derivative of the function with + * respect to al->ra[i] and al->ra[j] for all 0 <= i <= j < al->nr. + */ + +typedef void AddFunc ANSI(( + const char *name, + rfunc f, /* cast f to (rfunc) if it returns char* */ + int type, /* see FUNCADD_TYPE above */ + int nargs, /* >= 0 ==> exactly that many args + * <= -1 ==> at least -(nargs+1) args + */ + void *funcinfo, /* for use by the function (if desired) */ + AmplExports *ae + )); + +typedef void AddRand ANSI(( + const char *name, + rfunc f, /* assumed to be a random function */ + rfunc icdf, /* inverse CDF */ + int type, /* FUNCADD_STRING_ARGS or 0 */ + int nargs, /* >= 0 ==> exactly that many args + * <= -1 ==> at least -(nargs+1) args + */ + void *funcinfo, /* for use by the function (if desired) */ + AmplExports *ae + )); + +typedef void (*RandSeedSetter) ANSI((void*, unsigned long)); +typedef void AddRandInit ANSI((AmplExports *ae, RandSeedSetter, void*)); +typedef void Exitfunc ANSI((void*)); + + struct +AuxInfo { + AuxInfo *next; + char *auxname; + void *v; + void (*f) ANSI((AmplExports*, void*, ...)); + }; + + struct +AmplExports { + FILE *StdErr; + AddFunc *Addfunc; + long ASLdate; + int (*FprintF) ANSI((FILE*, const char*, ...)); + int (*PrintF) ANSI((const char*, ...)); + int (*SprintF) ANSI((char*, const char*, ...)); + int (*VfprintF) ANSI((FILE*, const char*, VA_LIST)); + int (*VsprintF) ANSI((char*, const char*, VA_LIST)); + double (*Strtod) ANSI((const char*, char**)); + cryptblock *(*Crypto) ANSI((char *key, size_t scrbytes)); + Char *asl; + void (*AtExit) ANSI((AmplExports *ae, Exitfunc*, void*)); + void (*AtReset) ANSI((AmplExports *ae, Exitfunc*, void*)); + Char *(*Tempmem) ANSI((TMInfo*, size_t)); + void (*Add_table_handler) ANSI(( + int (*DbRead) (AmplExports *ae, TableInfo *TI), + int (*DbWrite)(AmplExports *ae, TableInfo *TI), + char *handler_info, + int flags, + void *Vinfo + )); + Char *Private; + void (*Qsortv) ANSI((void*, size_t, size_t, int(*)(const void*,const void*,void*), void*)); + + /* More stuff for stdio in DLLs... */ + + FILE *StdIn; + FILE *StdOut; + void (*Clearerr) ANSI((FILE*)); + int (*Fclose) ANSI((FILE*)); + FILE* (*Fdopen) ANSI((int, const char*)); + int (*Feof) ANSI((FILE*)); + int (*Ferror) ANSI((FILE*)); + int (*Fflush) ANSI((FILE*)); + int (*Fgetc) ANSI((FILE*)); + char* (*Fgets) ANSI((char*, int, FILE*)); + int (*Fileno) ANSI((FILE*)); + FILE* (*Fopen) ANSI((const char*, const char*)); + int (*Fputc) ANSI((int, FILE*)); + int (*Fputs) ANSI((const char*, FILE*)); + size_t (*Fread) ANSI((void*, size_t, size_t, FILE*)); + FILE* (*Freopen) ANSI((const char*, const char*, FILE*)); + int (*Fscanf) ANSI((FILE*, const char*, ...)); + int (*Fseek) ANSI((FILE*, long, int)); + long (*Ftell) ANSI((FILE*)); + size_t (*Fwrite) ANSI((const void*, size_t, size_t, FILE*)); + int (*Pclose) ANSI((FILE*)); + void (*Perror) ANSI((const char*)); + FILE* (*Popen) ANSI((const char*, const char*)); + int (*Puts) ANSI((const char*)); + void (*Rewind) ANSI((FILE*)); + int (*Scanf) ANSI((const char*, ...)); + void (*Setbuf) ANSI((FILE*, char*)); + int (*Setvbuf) ANSI((FILE*, char*, int, size_t)); + int (*Sscanf) ANSI((const char*, const char*, ...)); + char* (*Tempnam) ANSI((const char*, const char*)); + FILE* (*Tmpfile) ANSI((void)); + char* (*Tmpnam) ANSI((char*)); + int (*Ungetc) ANSI((int, FILE*)); + AuxInfo *AI; + char* (*Getenv) ANSI((const char*)); + void (*Breakfunc) ANSI((int,void*)); + Char *Breakarg; + /* Items available with ASLdate >= 20020501 start here. */ + int (*SnprintF) ANSI((char*, size_t, const char*, ...)); + int (*VsnprintF) ANSI((char*, size_t, const char*, VA_LIST)); + + AddRand *Addrand; /* for random function/inverse CDF pairs */ + AddRandInit *Addrandinit; /* for adding a function to receive a new random seed */ + }; + +extern const char *i_option_ASL, *ix_details_ASL[]; + +#define funcadd funcadd_ASL + +#if defined(_WIN32) && !defined(__MINGW32__) +__declspec(dllexport) +#endif +extern void funcadd ANSI((AmplExports*)); /* dynamically linked */ +extern void af_libnamesave_ASL ANSI((AmplExports*, const char *fullname, const char *name, int nlen)); +extern void note_libuse_ASL ANSI((void)); /* If funcadd() does not provide any imported */ + /* functions, it can call note_libuse_ASL() to */ + /* keep the library loaded; note_libuse_ASL() is */ + /* called, e.g., by the tableproxy table handler. */ + +#ifdef __cplusplus + } +#endif + + typedef struct +DbCol { + real *dval; + char **sval; + } DbCol; + + struct +TableInfo { + int (*AddRows) ANSI((TableInfo *TI, DbCol *cols, long nrows)); + char *tname; /* name of this table */ + char **strings; + char **colnames; + DbCol *cols; + char *Missing; + char *Errmsg; + void *Vinfo; + TMInfo *TMI; + int nstrings; + int arity; + int ncols; + int flags; + long nrows; + void *Private; + int (*Lookup) ANSI((real*, char**, TableInfo*)); + long (*AdjustMaxrows) ANSI((TableInfo*, long new_maxrows)); + void *(*ColAlloc) ANSI((TableInfo*, int ncol, int sval)); + long maxrows; + }; + +enum { /* return values from (*DbRead)(...) and (*DbWrite)(...) */ + DB_Done = 0, /* Table read or written. */ + DB_Refuse = 1, /* Refuse to handle this table. */ + DB_Error = 2 /* Error reading or writing table. */ + }; + +enum { /* bits in flags field of TableInfo */ + DBTI_flags_IN = 1, /* table has IN or INOUT entities */ + DBTI_flags_OUT = 2, /* table has OUT or INOUT entities */ + DBTI_flags_INSET = 4 /* table has "in set" phrase: */ + /* DbRead could omit rows for */ + /* which Lookup(...) == -1; AMPL */ + /* will ignore such rows if DbRead */ + /* offers them. */ + }; + +#endif /* FUNCADD_H_INCLUDED */ + +#ifndef No_AE_redefs +/* Assume "{extern|static} AmplExports *ae;" is given elsewhere. */ +#undef Stderr +#undef addfunc +#undef fprintf +#undef getenv +#undef printf +#undef sprintf +#undef snprintf +#undef strtod +#undef vfprintf +#undef vsprintf +#undef vsnprintf +#define Stderr (ae->StdErr) +#define addfunc(a,b,c,d,e) (*ae->Addfunc)(a,b,c,d,e,ae) +#define addrand(a,b,c,d,e,f) (*ae->Addrand)(a,b,c,d,e,f,ae) +#define addrandinit(a,b) (*ae->Addrandinit)(ae,a,b) +#define printf (*ae->PrintF) +#define fprintf (*ae->FprintF) +#define snprintf (*ae->SnprintF) +#define sprintf (*ae->SprintF) +#define strtod (*ae->Strtod) +#define vfprintf (*ae->VfprintF) +#define vsprintf (*ae->VsprintF) +#define vsnprintf (*ae->VsnprintF) +#define TempMem(x,y) (*ae->Tempmem)(x,y) +#define at_exit(x,y) (*ae->AtExit)(ae,x,y) +#define at_reset(x,y) (*ae->AtReset)(ae,x,y) +#define add_table_handler(a,b,c,d,e) (*ae->Add_table_handler)(a,b,c,d,e) +#define qsortv(a,b,c,d,e) (*ae->Qsortv)(a,b,c,d,e) +#define getenv(x) (*ae->Getenv)(x) +#ifdef Stdio_redefs +#undef clearerr +#undef fclose +#undef fdopen +#undef feof +#undef ferror +#undef fflush +#undef fgetc +#undef fgets +#undef fileno +#undef fopen +#undef fputc +#undef fputs +#undef fread +#undef freopen +#undef fscanf +#undef fseek +#undef ftell +#undef fwrite +#undef getc +#undef getchar +#undef gets +#undef pclose +#undef perror +#undef popen +#undef putc +#undef putchar +#undef puts +#undef rewind +#undef scanf +#undef setbuf +#undef setvbuf +#undef sscanf +#undef tempnam +#undef tmpfile +#undef tmpnam +#undef ungetc +#undef vprintf +#define clearerr (*ae->Clearerr) +#define fclose (*ae->Fclose) +#define fdopen (*ae->Fdopen) +#define feof (*ae->Feof) +#define ferror (*ae->Ferror) +#define fflush (*ae->Fflush) +#define fgetc (*ae->Fgetc) +#define fgets (*ae->Fgets) +#define fileno (*ae->Fileno) +#define fopen (*ae->Fopen) +#define fputc (*ae->Fputc) +#define fputs (*ae->Fputs) +#define fread (*ae->Fread) +#define freopen (*ae->Freopen) +#define fscanf (*ae->Fscanf) +#define fseek (*ae->Fseek) +#define ftell (*ae->Ftell) +#define fwrite (*ae->Fwrite) +#define getc (*ae->Fgetc) +#define getchar() (*ae->Getc)(ae->StdIn) +#define gets Error - use "fgets" rather than "gets" +#define pclose (*ae->Pclose) +#define perror (*ae->Perror) +#define popen (*ae->Popen) +#define putc (*ae->Fputc) +#define putchar(x) (*ae->Fputc)(ae->StdOut,(x)) +#define puts (*ae->Puts) +#define rewind (*ae->Rewind) +#define scanf (*ae->Scanf) +#define setbuf (*ae->Setbuf) +#define setvbuf (*ae->Setvbuf) +#define sscanf (*ae->Sscanf) +#define tempnam (*ae->Tempnam) +#define tmpfile (*ae->Tmpfile) +#define tmpnam (*ae->Tmpnam) +#define ungetc (*ae->Ungetc) +#define vprintf(x,y) (*ae->VfprintF)(ae->StdOut,(x),(y)) +#define Stdin (ae->StdIn) +#define Stdout (ae->StdOut) +#ifndef No_std_FILE_redefs /* may elicit compiler warnings */ +#undef stdin +#undef stdout +#undef stderr +#define stdin (ae->StdIn) +#define stdout (ae->StdOut) +#define stderr (ae->StdErr) +#endif /* No_std_FILE_redefs */ +#endif /* Stdio_redefs */ +#endif /* ifndef No_AE_redefs */ + +/* DISCUSSION: the "at" field of an arglist... + * + * OUT and INOUT arguments are only permitted in AMPL commands, + * such as "let" and "call" commands (and not in declarations, e.g., + * of constraints and variables). + * + * When addfunc was called with type <= 6 (so there can be no OUT or + * INOUT arguments), for 0 <= i < n, + * at[i] >= 0 ==> arg i is ra[at[i]] + * at[i] < 0 ==> arg i is sa[-(at[i]+1)]. + * + * When addfunc was called with type & FUNCADD_OUTPUT_ARGS on (permitting + * OUT and INOUT arguments), arg i is in ra[i] or sa[i] (as explained + * below), derivs and hes are both null, and at[i] is the union of bits + * that describe arg i: + * AMPLFUNC_INARG = 1 ==> input arg; + * AMPLFUNC_OUTARG = 2 ==> output arg; + * AMPLFUNC_STROUT = 4 ==> can be assigned a string value. + * + * INOUT args have both the AMPLFUNC_INARG and the AMPLFUNC_OUTARG bits + * are on, i.e., (at[i] & 3) == 3. + * + * Symbolic OUT and INOUT arguments are a bit complicated. They can only + * correspond to symbolic parameters in AMPL, which may have either a + * string or a numeric value. Thus there is provision for specifying + * output values to be either numbers or strings. For simplicity, when + * the function accepts output arguments, ra[i] and sa[i] together describe + * argument i. In general (whentype & FUNCADD_OUTPUT_ARGS is nonzero in + * the addfunc call), the incoming value of argument i is ra[i] + * (a numeric value) if sa[i] is null and is otherwise sa[i]. + * To assign a value to argument i, either assign a numeric value to + * ra[i] and set sa[i] = 0, or assign a non-null value to sa[i] + * (in which case ra[i] will be ignored). A value assigned to argument + * i is ignored unless at[i] & AMPLFUNC_OUTARG is nonzero; if so + * and if (at[i] & AMPLFUNC_STROUT) == 0, string values cause an error + * message. + */ |