/* glpmpl.h (GNU MathProg translator) */

 /***********************************************************************

 *  This code is part of GLPK (GNU Linear Programming Kit).

 *

 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,

 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.

 *  E-mail: <mao@gnu.org>.

 *

 *  GLPK 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 3 of the License, or

 *  (at your option) any later version.

 *

 *  GLPK is distributed in the 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 GLPK. If not, see <http://www.gnu.org/licenses/>.

 ***********************************************************************/

 #ifndef GLPMPL_H

 #define GLPMPL_H

 #include "glpavl.h"

 #include "glprng.h"

 typedef struct MPL MPL;

 typedef char STRING;

 typedef struct SYMBOL SYMBOL;

 typedef struct TUPLE TUPLE;

 typedef struct ARRAY ELEMSET;

 typedef struct ELEMVAR ELEMVAR;

 typedef struct FORMULA FORMULA;

 typedef struct ELEMCON ELEMCON;

 typedef union VALUE VALUE;

 typedef struct ARRAY ARRAY;

 typedef struct MEMBER MEMBER;

 #if 1

 /* many C compilers have DOMAIN declared in <math.h> :( */

 #undef DOMAIN

 #define DOMAIN DOMAIN1

 #endif

 typedef struct DOMAIN DOMAIN;

 typedef struct DOMAIN_BLOCK DOMAIN_BLOCK;

 typedef struct DOMAIN_SLOT DOMAIN_SLOT;

 typedef struct SET SET;

 typedef struct WITHIN WITHIN;

 typedef struct GADGET GADGET;

 typedef struct PARAMETER PARAMETER;

 typedef struct CONDITION CONDITION;

 typedef struct VARIABLE VARIABLE;

 typedef struct CONSTRAINT CONSTRAINT;

 typedef struct TABLE TABLE;

 typedef struct TABARG TABARG;

 typedef struct TABFLD TABFLD;

 typedef struct TABIN TABIN;

 typedef struct TABOUT TABOUT;

 typedef struct TABDCA TABDCA;

 typedef union OPERANDS OPERANDS;

 typedef struct ARG_LIST ARG_LIST;

 typedef struct CODE CODE;

 typedef struct CHECK CHECK;

 typedef struct DISPLAY DISPLAY;

 typedef struct DISPLAY1 DISPLAY1;

 typedef struct PRINTF PRINTF;

 typedef struct PRINTF1 PRINTF1;

 typedef struct FOR FOR;

 typedef struct STATEMENT STATEMENT;

 typedef struct TUPLE SLICE;

 /**********************************************************************/

 /* * *                    TRANSLATOR DATABASE                     * * */

 /**********************************************************************/

 #define A_BINARY        101   /* something binary */

 #define A_CHECK         102   /* check statement */

 #define A_CONSTRAINT    103   /* model constraint */

 #define A_DISPLAY       104   /* display statement */

 #define A_ELEMCON       105   /* elemental constraint/objective */

 #define A_ELEMSET       106   /* elemental set */

 #define A_ELEMVAR       107   /* elemental variable */

 #define A_EXPRESSION    108   /* expression */

 #define A_FOR           109   /* for statement */

 #define A_FORMULA       110   /* formula */

 #define A_INDEX         111   /* dummy index */

 #define A_INPUT         112   /* input table */

 #define A_INTEGER       113   /* something integer */

 #define A_LOGICAL       114   /* something logical */

 #define A_MAXIMIZE      115   /* objective has to be maximized */

 #define A_MINIMIZE      116   /* objective has to be minimized */

 #define A_NONE          117   /* nothing */

 #define A_NUMERIC       118   /* something numeric */

 #define A_OUTPUT        119   /* output table */

 #define A_PARAMETER     120   /* model parameter */

 #define A_PRINTF        121   /* printf statement */

 #define A_SET           122   /* model set */

 #define A_SOLVE         123   /* solve statement */

 #define A_SYMBOLIC      124   /* something symbolic */

 #define A_TABLE         125   /* data table */

 #define A_TUPLE         126   /* n-tuple */

 #define A_VARIABLE      127   /* model variable */

 #define MAX_LENGTH 100

 /* maximal length of any symbolic value (this includes symbolic names,

    numeric and string literals, and all symbolic values that may appear

    during the evaluation phase) */

 #define CONTEXT_SIZE 60

 /* size of the context queue, in characters */

 #define OUTBUF_SIZE 1024

 /* size of the output buffer, in characters */

 struct MPL

 {     /* translator database */

       /*--------------------------------------------------------------*/

       /* scanning segment */

       int line;

       /* number of the current text line */

       int c;

       /* the current character or EOF */

       int token;

       /* the current token: */

 #define T_EOF           201   /* end of file */

 #define T_NAME          202   /* symbolic name (model section only) */

 #define T_SYMBOL        203   /* symbol (data section only) */

 #define T_NUMBER        204   /* numeric literal */

 #define T_STRING        205   /* string literal */

 #define T_AND           206   /* and && */

 #define T_BY            207   /* by */

 #define T_CROSS         208   /* cross */

 #define T_DIFF          209   /* diff */

 #define T_DIV           210   /* div */

 #define T_ELSE          211   /* else */

 #define T_IF            212   /* if */

 #define T_IN            213   /* in */

 #define T_INFINITY      214   /* Infinity */

 #define T_INTER         215   /* inter */

 #define T_LESS          216   /* less */

 #define T_MOD           217   /* mod */

 #define T_NOT           218   /* not ! */

 #define T_OR            219   /* or || */

 #define T_SPTP          220   /* s.t. */

 #define T_SYMDIFF       221   /* symdiff */

 #define T_THEN          222   /* then */

 #define T_UNION         223   /* union */

 #define T_WITHIN        224   /* within */

 #define T_PLUS          225   /* + */

 #define T_MINUS         226   /* - */

 #define T_ASTERISK      227   /* * */

 #define T_SLASH         228   /* / */

 #define T_POWER         229   /* ^ ** */

 #define T_LT            230   /* <  */

 #define T_LE            231   /* <= */

 #define T_EQ            232   /* = == */

 #define T_GE            233   /* >= */

 #define T_GT            234   /* >  */

 #define T_NE            235   /* <> != */

 #define T_CONCAT        236   /* & */

 #define T_BAR           237   /* | */

 #define T_POINT         238   /* . */

 #define T_COMMA         239   /* , */

 #define T_COLON         240   /* : */

 #define T_SEMICOLON     241   /* ; */

 #define T_ASSIGN        242   /* := */

 #define T_DOTS          243   /* .. */

 #define T_LEFT          244   /* ( */

 #define T_RIGHT         245   /* ) */

 #define T_LBRACKET      246   /* [ */

 #define T_RBRACKET      247   /* ] */

 #define T_LBRACE        248   /* { */

 #define T_RBRACE        249   /* } */

 #define T_APPEND        250   /* >> */

 #define T_TILDE         251   /* ~ */

 #define T_INPUT         252   /* <- */

       int imlen;

       /* length of the current token */

       char *image; /* char image[MAX_LENGTH+1]; */

       /* image of the current token */

       double value;

       /* value of the current token (for T_NUMBER only) */

       int b_token;

       /* the previous token */

       int b_imlen;

       /* length of the previous token */

       char *b_image; /* char b_image[MAX_LENGTH+1]; */

       /* image of the previous token */

       double b_value;

       /* value of the previous token (if token is T_NUMBER) */

       int f_dots;

       /* if this flag is set, the next token should be recognized as

          T_DOTS, not as T_POINT */

       int f_scan;

       /* if this flag is set, the next token is already scanned */

       int f_token;

       /* the next token */

       int f_imlen;

       /* length of the next token */

       char *f_image; /* char f_image[MAX_LENGTH+1]; */

       /* image of the next token */

       double f_value;

       /* value of the next token (if token is T_NUMBER) */

       char *context; /* char context[CONTEXT_SIZE]; */

       /* context circular queue (not null-terminated!) */

       int c_ptr;

       /* pointer to the current position in the context queue */

       int flag_d;

       /* if this flag is set, the data section is being processed */

       /*--------------------------------------------------------------*/

       /* translating segment */

       DMP *pool;

       /* memory pool used to allocate all data instances created during

          the translation phase */

       AVL *tree;

       /* symbolic name table:

          node.type = A_INDEX     => node.link -> DOMAIN_SLOT

          node.type = A_SET       => node.link -> SET

          node.type = A_PARAMETER => node.link -> PARAMETER

          node.type = A_VARIABLE  => node.link -> VARIABLE

          node.type = A_CONSTRANT => node.link -> CONSTRAINT */

       STATEMENT *model;

       /* linked list of model statements in the original order */

       int flag_x;

       /* if this flag is set, the current token being left parenthesis

          begins a slice that allows recognizing any undeclared symbolic

          names as dummy indices; this flag is automatically reset once

          the next token has been scanned */

       int as_within;

       /* the warning "in understood as within" has been issued */

       int as_in;

       /* the warning "within understood as in" has been issued */

       int as_binary;

       /* the warning "logical understood as binary" has been issued */

       int flag_s;

       /* if this flag is set, the solve statement has been parsed */

       /*--------------------------------------------------------------*/

       /* common segment */

       DMP *strings;

       /* memory pool to allocate STRING data structures */

       DMP *symbols;

       /* memory pool to allocate SYMBOL data structures */

       DMP *tuples;

       /* memory pool to allocate TUPLE data structures */

       DMP *arrays;

       /* memory pool to allocate ARRAY data structures */

       DMP *members;

       /* memory pool to allocate MEMBER data structures */

       DMP *elemvars;

       /* memory pool to allocate ELEMVAR data structures */

       DMP *formulae;

       /* memory pool to allocate FORMULA data structures */

       DMP *elemcons;

       /* memory pool to allocate ELEMCON data structures */

       ARRAY *a_list;

       /* linked list of all arrays in the database */

       char *sym_buf; /* char sym_buf[255+1]; */

       /* working buffer used by the routine format_symbol */

       char *tup_buf; /* char tup_buf[255+1]; */

       /* working buffer used by the routine format_tuple */

       /*--------------------------------------------------------------*/

       /* generating/postsolving segment */

       RNG *rand;

       /* pseudo-random number generator */

       int flag_p;

       /* if this flag is set, the postsolving phase is in effect */

       STATEMENT *stmt;

       /* model statement being currently executed */

       TABDCA *dca;

       /* pointer to table driver communication area for table statement

          currently executed */

       int m;

       /* number of rows in the problem, m >= 0 */

       int n;

       /* number of columns in the problem, n >= 0 */

       ELEMCON **row; /* ELEMCON *row[1+m]; */

       /* row[0] is not used;

          row[i] is elemental constraint or objective, which corresponds

          to i-th row of the problem, 1 <= i <= m */

       ELEMVAR **col; /* ELEMVAR *col[1+n]; */

       /* col[0] is not used;

          col[j] is elemental variable, which corresponds to j-th column

          of the problem, 1 <= j <= n */

       /*--------------------------------------------------------------*/

       /* input/output segment */

       XFILE *in_fp;

       /* stream assigned to the input text file */

       char *in_file;

       /* name of the input text file */

       XFILE *out_fp;

       /* stream assigned to the output text file used to write all data

          produced by display and printf statements; NULL means the data

          should be sent to stdout via the routine xprintf */

       char *out_file;

       /* name of the output text file */

 #if 0 /* 08/XI-2009 */

       char *out_buf; /* char out_buf[OUTBUF_SIZE] */

       /* buffer to accumulate output data */

       int out_cnt;

       /* count of data bytes stored in the output buffer */

 #endif

       XFILE *prt_fp;

       /* stream assigned to the print text file; may be NULL */

       char *prt_file;

       /* name of the output print file */

       /*--------------------------------------------------------------*/

       /* solver interface segment */

       jmp_buf jump;

       /* jump address for non-local go to in case of error */

       int phase;

       /* phase of processing:

          0 - database is being or has been initialized

          1 - model section is being or has been read

          2 - data section is being or has been read

          3 - model is being or has been generated/postsolved

          4 - model processing error has occurred */

       char *mod_file;

       /* name of the input text file, which contains model section */

       char *mpl_buf; /* char mpl_buf[255+1]; */

       /* working buffer used by some interface routines */

 };

 /**********************************************************************/

 /* * *                  PROCESSING MODEL SECTION                  * * */

 /**********************************************************************/

 #define alloc(type) ((type *)dmp_get_atomv(mpl->pool, sizeof(type)))

 /* allocate atom of given type */

 #define enter_context _glp_mpl_enter_context

 void enter_context(MPL *mpl);

 /* enter current token into context queue */

 #define print_context _glp_mpl_print_context

 void print_context(MPL *mpl);

 /* print current content of context queue */

 #define get_char _glp_mpl_get_char

 void get_char(MPL *mpl);

 /* scan next character from input text file */

 #define append_char _glp_mpl_append_char

 void append_char(MPL *mpl);

 /* append character to current token */

 #define get_token _glp_mpl_get_token

 void get_token(MPL *mpl);

 /* scan next token from input text file */

 #define unget_token _glp_mpl_unget_token

 void unget_token(MPL *mpl);

 /* return current token back to input stream */

 #define is_keyword _glp_mpl_is_keyword

 int is_keyword(MPL *mpl, char *keyword);

 /* check if current token is given non-reserved keyword */

 #define is_reserved _glp_mpl_is_reserved

 int is_reserved(MPL *mpl);

 /* check if current token is reserved keyword */

 #define make_code _glp_mpl_make_code

 CODE *make_code(MPL *mpl, int op, OPERANDS *arg, int type, int dim);

 /* generate pseudo-code (basic routine) */

 #define make_unary _glp_mpl_make_unary

 CODE *make_unary(MPL *mpl, int op, CODE *x, int type, int dim);

 /* generate pseudo-code for unary operation */

 #define make_binary _glp_mpl_make_binary

 CODE *make_binary(MPL *mpl, int op, CODE *x, CODE *y, int type,

       int dim);

 /* generate pseudo-code for binary operation */

 #define make_ternary _glp_mpl_make_ternary

 CODE *make_ternary(MPL *mpl, int op, CODE *x, CODE *y, CODE *z,

       int type, int dim);

 /* generate pseudo-code for ternary operation */

 #define numeric_literal _glp_mpl_numeric_literal

 CODE *numeric_literal(MPL *mpl);

 /* parse reference to numeric literal */

 #define string_literal _glp_mpl_string_literal

 CODE *string_literal(MPL *mpl);

 /* parse reference to string literal */

 #define create_arg_list _glp_mpl_create_arg_list

 ARG_LIST *create_arg_list(MPL *mpl);

 /* create empty operands list */

 #define expand_arg_list _glp_mpl_expand_arg_list

 ARG_LIST *expand_arg_list(MPL *mpl, ARG_LIST *list, CODE *x);

 /* append operand to operands list */

 #define arg_list_len _glp_mpl_arg_list_len

 int arg_list_len(MPL *mpl, ARG_LIST *list);

 /* determine length of operands list */

 #define subscript_list _glp_mpl_subscript_list

 ARG_LIST *subscript_list(MPL *mpl);

 /* parse subscript list */

 #define object_reference _glp_mpl_object_reference

 CODE *object_reference(MPL *mpl);

 /* parse reference to named object */

 #define numeric_argument _glp_mpl_numeric_argument

 CODE *numeric_argument(MPL *mpl, char *func);

 /* parse argument passed to built-in function */

 #define symbolic_argument _glp_mpl_symbolic_argument

 CODE *symbolic_argument(MPL *mpl, char *func);

 #define elemset_argument _glp_mpl_elemset_argument

 CODE *elemset_argument(MPL *mpl, char *func);

 #define function_reference _glp_mpl_function_reference

 CODE *function_reference(MPL *mpl);

 /* parse reference to built-in function */

 #define create_domain _glp_mpl_create_domain

 DOMAIN *create_domain(MPL *mpl);

 /* create empty domain */

 #define create_block _glp_mpl_create_block

 DOMAIN_BLOCK *create_block(MPL *mpl);

 /* create empty domain block */

 #define append_block _glp_mpl_append_block

 void append_block(MPL *mpl, DOMAIN *domain, DOMAIN_BLOCK *block);

 /* append domain block to specified domain */

 #define append_slot _glp_mpl_append_slot

 DOMAIN_SLOT *append_slot(MPL *mpl, DOMAIN_BLOCK *block, char *name,

       CODE *code);

 /* create and append new slot to domain block */

 #define expression_list _glp_mpl_expression_list

 CODE *expression_list(MPL *mpl);

 /* parse expression list */

 #define literal_set _glp_mpl_literal_set

 CODE *literal_set(MPL *mpl, CODE *code);

 /* parse literal set */

 #define indexing_expression _glp_mpl_indexing_expression

 DOMAIN *indexing_expression(MPL *mpl);

 /* parse indexing expression */

 #define close_scope _glp_mpl_close_scope

 void close_scope(MPL *mpl, DOMAIN *domain);

 /* close scope of indexing expression */

 #define iterated_expression _glp_mpl_iterated_expression

 CODE *iterated_expression(MPL *mpl);

 /* parse iterated expression */

 #define domain_arity _glp_mpl_domain_arity

 int domain_arity(MPL *mpl, DOMAIN *domain);

 /* determine arity of domain */

 #define set_expression _glp_mpl_set_expression

 CODE *set_expression(MPL *mpl);

 /* parse set expression */

 #define branched_expression _glp_mpl_branched_expression

 CODE *branched_expression(MPL *mpl);

 /* parse conditional expression */

 #define primary_expression _glp_mpl_primary_expression

 CODE *primary_expression(MPL *mpl);

 /* parse primary expression */

 #define error_preceding _glp_mpl_error_preceding

 void error_preceding(MPL *mpl, char *opstr);

 /* raise error if preceding operand has wrong type */

 #define error_following _glp_mpl_error_following

 void error_following(MPL *mpl, char *opstr);

 /* raise error if following operand has wrong type */

 #define error_dimension _glp_mpl_error_dimension

 void error_dimension(MPL *mpl, char *opstr, int dim1, int dim2);

 /* raise error if operands have different dimension */

 #define expression_0 _glp_mpl_expression_0

 CODE *expression_0(MPL *mpl);

 /* parse expression of level 0 */

 #define expression_1 _glp_mpl_expression_1

 CODE *expression_1(MPL *mpl);

 /* parse expression of level 1 */

 #define expression_2 _glp_mpl_expression_2

 CODE *expression_2(MPL *mpl);

 /* parse expression of level 2 */

 #define expression_3 _glp_mpl_expression_3

 CODE *expression_3(MPL *mpl);

 /* parse expression of level 3 */

 #define expression_4 _glp_mpl_expression_4

 CODE *expression_4(MPL *mpl);

 /* parse expression of level 4 */

 #define expression_5 _glp_mpl_expression_5

 CODE *expression_5(MPL *mpl);

 /* parse expression of level 5 */

 #define expression_6 _glp_mpl_expression_6

 CODE *expression_6(MPL *mpl);

 /* parse expression of level 6 */

 #define expression_7 _glp_mpl_expression_7

 CODE *expression_7(MPL *mpl);

 /* parse expression of level 7 */

 #define expression_8 _glp_mpl_expression_8

 CODE *expression_8(MPL *mpl);

 /* parse expression of level 8 */

 #define expression_9 _glp_mpl_expression_9

 CODE *expression_9(MPL *mpl);

 /* parse expression of level 9 */

 #define expression_10 _glp_mpl_expression_10

 CODE *expression_10(MPL *mpl);

 /* parse expression of level 10 */

 #define expression_11 _glp_mpl_expression_11

 CODE *expression_11(MPL *mpl);

 /* parse expression of level 11 */

 #define expression_12 _glp_mpl_expression_12

 CODE *expression_12(MPL *mpl);

 /* parse expression of level 12 */

 #define expression_13 _glp_mpl_expression_13

 CODE *expression_13(MPL *mpl);

 /* parse expression of level 13 */

 #define set_statement _glp_mpl_set_statement

 SET *set_statement(MPL *mpl);

 /* parse set statement */

 #define parameter_statement _glp_mpl_parameter_statement

 PARAMETER *parameter_statement(MPL *mpl);

 /* parse parameter statement */

 #define variable_statement _glp_mpl_variable_statement

 VARIABLE *variable_statement(MPL *mpl);

 /* parse variable statement */

 #define constraint_statement _glp_mpl_constraint_statement

 CONSTRAINT *constraint_statement(MPL *mpl);

 /* parse constraint statement */

 #define objective_statement _glp_mpl_objective_statement

 CONSTRAINT *objective_statement(MPL *mpl);

 /* parse objective statement */

 #define table_statement _glp_mpl_table_statement

 TABLE *table_statement(MPL *mpl);

 /* parse table statement */

 #define solve_statement _glp_mpl_solve_statement

 void *solve_statement(MPL *mpl);

 /* parse solve statement */

 #define check_statement _glp_mpl_check_statement

 CHECK *check_statement(MPL *mpl);

 /* parse check statement */

 #define display_statement _glp_mpl_display_statement

 DISPLAY *display_statement(MPL *mpl);

 /* parse display statement */

 #define printf_statement _glp_mpl_printf_statement

 PRINTF *printf_statement(MPL *mpl);

 /* parse printf statement */

 #define for_statement _glp_mpl_for_statement

 FOR *for_statement(MPL *mpl);

 /* parse for statement */

 #define end_statement _glp_mpl_end_statement

 void end_statement(MPL *mpl);

 /* parse end statement */

 #define simple_statement _glp_mpl_simple_statement

 STATEMENT *simple_statement(MPL *mpl, int spec);

 /* parse simple statement */

 #define model_section _glp_mpl_model_section

 void model_section(MPL *mpl);

 /* parse model section */

 /**********************************************************************/

 /* * *                  PROCESSING DATA SECTION                   * * */

 /**********************************************************************/

 #if 2 + 2 == 5

 struct SLICE /* see TUPLE */

 {     /* component of slice; the slice itself is associated with its

          first component; slices are similar to n-tuples with exception

          that some slice components (which are indicated by asterisks)

          don't refer to any symbols */

       SYMBOL *sym;

       /* symbol, which this component refers to; can be NULL */

       SLICE *next;

       /* the next component of slice */

 };

 #endif

 #define create_slice _glp_mpl_create_slice

 SLICE *create_slice(MPL *mpl);

 /* create slice */

 #define expand_slice _glp_mpl_expand_slice

 SLICE *expand_slice

 (     MPL *mpl,

       SLICE *slice,           /* destroyed */

       SYMBOL *sym             /* destroyed */

 );

 /* append new component to slice */

 #define slice_dimen _glp_mpl_slice_dimen

 int slice_dimen

 (     MPL *mpl,

       SLICE *slice            /* not changed */

 );

 /* determine dimension of slice */

 #define slice_arity _glp_mpl_slice_arity

 int slice_arity

 (     MPL *mpl,

       SLICE *slice            /* not changed */

 );

 /* determine arity of slice */

 #define fake_slice _glp_mpl_fake_slice

 SLICE *fake_slice(MPL *mpl, int dim);

 /* create fake slice of all asterisks */

 #define delete_slice _glp_mpl_delete_slice

 void delete_slice

 (     MPL *mpl,

       SLICE *slice            /* destroyed */

 );

 /* delete slice */

 #define is_number _glp_mpl_is_number

 int is_number(MPL *mpl);

 /* check if current token is number */

 #define is_symbol _glp_mpl_is_symbol

 int is_symbol(MPL *mpl);

 /* check if current token is symbol */

 #define is_literal _glp_mpl_is_literal

 int is_literal(MPL *mpl, char *literal);

 /* check if current token is given symbolic literal */

 #define read_number _glp_mpl_read_number

 double read_number(MPL *mpl);

 /* read number */

 #define read_symbol _glp_mpl_read_symbol

 SYMBOL *read_symbol(MPL *mpl);

 /* read symbol */

 #define read_slice _glp_mpl_read_slice

 SLICE *read_slice

 (     MPL *mpl,

       char *name,             /* not changed */

       int dim

 );

 /* read slice */

 #define select_set _glp_mpl_select_set

 SET *select_set

 (     MPL *mpl,

       char *name              /* not changed */

 );

 /* select set to saturate it with elemental sets */

 #define simple_format _glp_mpl_simple_format

 void simple_format

 (     MPL *mpl,

       SET *set,               /* not changed */

       MEMBER *memb,           /* modified */

       SLICE *slice            /* not changed */

 );

 /* read set data block in simple format */

 #define matrix_format _glp_mpl_matrix_format

 void matrix_format

 (     MPL *mpl,

       SET *set,               /* not changed */

       MEMBER *memb,           /* modified */

       SLICE *slice,           /* not changed */

       int tr

 );

 /* read set data block in matrix format */

 #define set_data _glp_mpl_set_data

 void set_data(MPL *mpl);

 /* read set data */

 #define select_parameter _glp_mpl_select_parameter

 PARAMETER *select_parameter

 (     MPL *mpl,

       char *name              /* not changed */

 );

 /* select parameter to saturate it with data */

 #define set_default _glp_mpl_set_default

 void set_default

 (     MPL *mpl,

       PARAMETER *par,         /* not changed */

       SYMBOL *altval          /* destroyed */

 );

 /* set default parameter value */

 #define read_value _glp_mpl_read_value

 MEMBER *read_value

 (     MPL *mpl,

       PARAMETER *par,         /* not changed */

       TUPLE *tuple            /* destroyed */

 );

 /* read value and assign it to parameter member */

 #define plain_format _glp_mpl_plain_format

 void plain_format

 (     MPL *mpl,

       PARAMETER *par,         /* not changed */

       SLICE *slice            /* not changed */

 );

 /* read parameter data block in plain format */

 #define tabular_format _glp_mpl_tabular_format

 void tabular_format

 (     MPL *mpl,

       PARAMETER *par,         /* not changed */

       SLICE *slice,           /* not changed */

       int tr

 );

 /* read parameter data block in tabular format */

 #define tabbing_format _glp_mpl_tabbing_format

 void tabbing_format

 (     MPL *mpl,

       SYMBOL *altval          /* not changed */

 );

 /* read parameter data block in tabbing format */

 #define parameter_data _glp_mpl_parameter_data

 void parameter_data(MPL *mpl);

 /* read parameter data */

 #define data_section _glp_mpl_data_section

 void data_section(MPL *mpl);

 /* read data section */

 /**********************************************************************/

 /* * *                   FLOATING-POINT NUMBERS                   * * */

 /**********************************************************************/

 #define fp_add _glp_mpl_fp_add

 double fp_add(MPL *mpl, double x, double y);

 /* floating-point addition */

 #define fp_sub _glp_mpl_fp_sub

 double fp_sub(MPL *mpl, double x, double y);

 /* floating-point subtraction */

 #define fp_less _glp_mpl_fp_less

 double fp_less(MPL *mpl, double x, double y);

 /* floating-point non-negative subtraction */

 #define fp_mul _glp_mpl_fp_mul

 double fp_mul(MPL *mpl, double x, double y);

 /* floating-point multiplication */

 #define fp_div _glp_mpl_fp_div

 double fp_div(MPL *mpl, double x, double y);

 /* floating-point division */

 #define fp_idiv _glp_mpl_fp_idiv

 double fp_idiv(MPL *mpl, double x, double y);

 /* floating-point quotient of exact division */

 #define fp_mod _glp_mpl_fp_mod

 double fp_mod(MPL *mpl, double x, double y);

 /* floating-point remainder of exact division */

 #define fp_power _glp_mpl_fp_power

 double fp_power(MPL *mpl, double x, double y);

 /* floating-point exponentiation (raise to power) */

 #define fp_exp _glp_mpl_fp_exp

 double fp_exp(MPL *mpl, double x);

 /* floating-point base-e exponential */

 #define fp_log _glp_mpl_fp_log

 double fp_log(MPL *mpl, double x);

 /* floating-point natural logarithm */

 #define fp_log10 _glp_mpl_fp_log10

 double fp_log10(MPL *mpl, double x);

 /* floating-point common (decimal) logarithm */

 #define fp_sqrt _glp_mpl_fp_sqrt

 double fp_sqrt(MPL *mpl, double x);

 /* floating-point square root */

 #define fp_sin _glp_mpl_fp_sin

 double fp_sin(MPL *mpl, double x);

 /* floating-point trigonometric sine */

 #define fp_cos _glp_mpl_fp_cos

 double fp_cos(MPL *mpl, double x);

 /* floating-point trigonometric cosine */

 #define fp_atan _glp_mpl_fp_atan

 double fp_atan(MPL *mpl, double x);

 /* floating-point trigonometric arctangent */

 #define fp_atan2 _glp_mpl_fp_atan2

 double fp_atan2(MPL *mpl, double y, double x);

 /* floating-point trigonometric arctangent */

 #define fp_round _glp_mpl_fp_round

 double fp_round(MPL *mpl, double x, double n);

 /* round floating-point value to n fractional digits */

 #define fp_trunc _glp_mpl_fp_trunc

 double fp_trunc(MPL *mpl, double x, double n);

 /* truncate floating-point value to n fractional digits */

 /**********************************************************************/

 /* * *              PSEUDO-RANDOM NUMBER GENERATORS               * * */

 /**********************************************************************/

 #define fp_irand224 _glp_mpl_fp_irand224

 double fp_irand224(MPL *mpl);

 /* pseudo-random integer in the range [0, 2^24) */

 #define fp_uniform01 _glp_mpl_fp_uniform01

 double fp_uniform01(MPL *mpl);

 /* pseudo-random number in the range [0, 1) */

 #define fp_uniform _glp_mpl_uniform

 double fp_uniform(MPL *mpl, double a, double b);

 /* pseudo-random number in the range [a, b) */

 #define fp_normal01 _glp_mpl_fp_normal01

 double fp_normal01(MPL *mpl);

 /* Gaussian random variate with mu = 0 and sigma = 1 */

 #define fp_normal _glp_mpl_fp_normal

 double fp_normal(MPL *mpl, double mu, double sigma);

 /* Gaussian random variate with specified mu and sigma */

 /**********************************************************************/

 /* * *                         DATE/TIME                          * * */

 /**********************************************************************/

 #define fn_gmtime _glp_mpl_fn_gmtime

 double fn_gmtime(MPL *mpl);

 /* obtain the current calendar time (UTC) */

 #define fn_str2time _glp_mpl_fn_str2time

 double fn_str2time(MPL *mpl, const char *str, const char *fmt);

 /* convert character string to the calendar time */

 #define fn_time2str _glp_mpl_fn_time2str

 void fn_time2str(MPL *mpl, char *str, double t, const char *fmt);

 /* convert the calendar time to character string */

 /**********************************************************************/

 /* * *                     CHARACTER STRINGS                      * * */

 /**********************************************************************/

 #define create_string _glp_mpl_create_string

 STRING *create_string

 (     MPL *mpl,

       char buf[MAX_LENGTH+1]  /* not changed */

 );

 /* create character string */

 #define copy_string _glp_mpl_copy_string

 STRING *copy_string

 (     MPL *mpl,

       STRING *str             /* not changed */

 );

 /* make copy of character string */

 #define compare_strings _glp_mpl_compare_strings

 int compare_strings

 (     MPL *mpl,

       STRING *str1,           /* not changed */

       STRING *str2            /* not changed */

 );

 /* compare one character string with another */

 #define fetch_string _glp_mpl_fetch_string

 char *fetch_string

 (     MPL *mpl,

       STRING *str,            /* not changed */

       char buf[MAX_LENGTH+1]  /* modified */

 );

 /* extract content of character string */

 #define delete_string _glp_mpl_delete_string

 void delete_string

 (     MPL *mpl,

       STRING *str             /* destroyed */

 );

 /* delete character string */

 /**********************************************************************/

 /* * *                          SYMBOLS                           * * */

 /**********************************************************************/

 struct SYMBOL

 {     /* symbol (numeric or abstract quantity) */

       double num;

       /* numeric value of symbol (used only if str == NULL) */

       STRING *str;

       /* abstract value of symbol (used only if str != NULL) */

 };

 #define create_symbol_num _glp_mpl_create_symbol_num

 SYMBOL *create_symbol_num(MPL *mpl, double num);

 /* create symbol of numeric type */

 #define create_symbol_str _glp_mpl_create_symbol_str

 SYMBOL *create_symbol_str

 (     MPL *mpl,

       STRING *str             /* destroyed */

 );

 /* create symbol of abstract type */

 #define copy_symbol _glp_mpl_copy_symbol

 SYMBOL *copy_symbol

 (     MPL *mpl,

       SYMBOL *sym             /* not changed */

 );

 /* make copy of symbol */

 #define compare_symbols _glp_mpl_compare_symbols

 int compare_symbols

 (     MPL *mpl,

       SYMBOL *sym1,           /* not changed */

       SYMBOL *sym2            /* not changed */

 );

 /* compare one symbol with another */

 #define delete_symbol _glp_mpl_delete_symbol

 void delete_symbol

 (     MPL *mpl,

       SYMBOL *sym             /* destroyed */

 );

 /* delete symbol */

 #define format_symbol _glp_mpl_format_symbol

 char *format_symbol

 (     MPL *mpl,

       SYMBOL *sym             /* not changed */

 );

 /* format symbol for displaying or printing */

 #define concat_symbols _glp_mpl_concat_symbols

 SYMBOL *concat_symbols

 (     MPL *mpl,

       SYMBOL *sym1,           /* destroyed */

       SYMBOL *sym2            /* destroyed */

 );

 /* concatenate one symbol with another */

 /**********************************************************************/

 /* * *                          N-TUPLES                          * * */

 /**********************************************************************/

 struct TUPLE

 {     /* component of n-tuple; the n-tuple itself is associated with

          its first component; (note that 0-tuple has no components) */

       SYMBOL *sym;

       /* symbol, which the component refers to; cannot be NULL */

       TUPLE *next;

       /* the next component of n-tuple */

 };

 #define create_tuple _glp_mpl_create_tuple

 TUPLE *create_tuple(MPL *mpl);

 /* create n-tuple */

 #define expand_tuple _glp_mpl_expand_tuple

 TUPLE *expand_tuple

 (     MPL *mpl,

       TUPLE *tuple,           /* destroyed */

       SYMBOL *sym             /* destroyed */

 );

 /* append symbol to n-tuple */

 #define tuple_dimen _glp_mpl_tuple_dimen

 int tuple_dimen

 (     MPL *mpl,

       TUPLE *tuple            /* not changed */

 );

 /* determine dimension of n-tuple */

 #define copy_tuple _glp_mpl_copy_tuple

 TUPLE *copy_tuple

 (     MPL *mpl,

       TUPLE *tuple            /* not changed */

 );

 /* make copy of n-tuple */

 #define compare_tuples _glp_mpl_compare_tuples

 int compare_tuples

 (     MPL *mpl,

       TUPLE *tuple1,          /* not changed */

       TUPLE *tuple2           /* not changed */

 );

 /* compare one n-tuple with another */

 #define build_subtuple _glp_mpl_build_subtuple

 TUPLE *build_subtuple

 (     MPL *mpl,

       TUPLE *tuple,           /* not changed */

       int dim

 );

 /* build subtuple of given n-tuple */

 #define delete_tuple _glp_mpl_delete_tuple

 void delete_tuple

 (     MPL *mpl,

       TUPLE *tuple            /* destroyed */

 );

 /* delete n-tuple */

 #define format_tuple _glp_mpl_format_tuple

 char *format_tuple

 (     MPL *mpl,

       int c,

       TUPLE *tuple            /* not changed */

 );

 /* format n-tuple for displaying or printing */

 /**********************************************************************/

 /* * *                       ELEMENTAL SETS                       * * */

 /**********************************************************************/

 #if 2 + 2 == 5

 struct ELEMSET /* see ARRAY */

 {     /* elemental set of n-tuples; formally it is a "value" assigned

          to members of model sets (like numbers and symbols, which are

          values assigned to members of model parameters); note that a

          simple model set is not an elemental set, it is 0-dimensional

          array, the only member of which (if it exists) is assigned an

          elemental set */

 #endif

 #define create_elemset _glp_mpl_create_elemset

 ELEMSET *create_elemset(MPL *mpl, int dim);

 /* create elemental set */

 #define find_tuple _glp_mpl_find_tuple

 MEMBER *find_tuple

 (     MPL *mpl,

       ELEMSET *set,           /* not changed */

       TUPLE *tuple            /* not changed */

 );

 /* check if elemental set contains given n-tuple */

 #define add_tuple _glp_mpl_add_tuple

 MEMBER *add_tuple

 (     MPL *mpl,

       ELEMSET *set,           /* modified */

       TUPLE *tuple            /* destroyed */

 );

 /* add new n-tuple to elemental set */

 #define check_then_add _glp_mpl_check_then_add

 MEMBER *check_then_add

 (     MPL *mpl,

       ELEMSET *set,           /* modified */

       TUPLE *tuple            /* destroyed */

 );

 /* check and add new n-tuple to elemental set */

 #define copy_elemset _glp_mpl_copy_elemset

 ELEMSET *copy_elemset

 (     MPL *mpl,

       ELEMSET *set            /* not changed */

 );

 /* make copy of elemental set */

 #define delete_elemset _glp_mpl_delete_elemset

 void delete_elemset

 (     MPL *mpl,

       ELEMSET *set            /* destroyed */

 );

 /* delete elemental set */

 #define arelset_size _glp_mpl_arelset_size

 int arelset_size(MPL *mpl, double t0, double tf, double dt);

 /* compute size of "arithmetic" elemental set */

 #define arelset_member _glp_mpl_arelset_member

 double arelset_member(MPL *mpl, double t0, double tf, double dt, int j);

 /* compute member of "arithmetic" elemental set */

 #define create_arelset _glp_mpl_create_arelset

 ELEMSET *create_arelset(MPL *mpl, double t0, double tf, double dt);

 /* create "arithmetic" elemental set */

 #define set_union _glp_mpl_set_union

 ELEMSET *set_union

 (     MPL *mpl,

       ELEMSET *X,             /* destroyed */

       ELEMSET *Y              /* destroyed */

 );

 /* union of two elemental sets */

 #define set_diff _glp_mpl_set_diff

 ELEMSET *set_diff

 (     MPL *mpl,

       ELEMSET *X,             /* destroyed */

       ELEMSET *Y              /* destroyed */