COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

source: glpk-cmake/src/glpmpl.h @ 2:4c8956a7bdf4

Last change on this file since 2:4c8956a7bdf4 was 1:c445c931472f, checked in by Alpar Juttner <alpar@…>, 14 years ago

Import glpk-4.45

  • Generated files and doc/notes are removed
File size: 87.6 KB
RevLine 
[1]1/* glpmpl.h (GNU MathProg translator) */
2
3/***********************************************************************
4*  This code is part of GLPK (GNU Linear Programming Kit).
5*
6*  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7*  2009, 2010 Andrew Makhorin, Department for Applied Informatics,
8*  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
9*  E-mail: <mao@gnu.org>.
10*
11*  GLPK is free software: you can redistribute it and/or modify it
12*  under the terms of the GNU General Public License as published by
13*  the Free Software Foundation, either version 3 of the License, or
14*  (at your option) any later version.
15*
16*  GLPK is distributed in the hope that it will be useful, but WITHOUT
17*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19*  License for more details.
20*
21*  You should have received a copy of the GNU General Public License
22*  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
23***********************************************************************/
24
25#ifndef GLPMPL_H
26#define GLPMPL_H
27
28#include "glpavl.h"
29#include "glprng.h"
30
31typedef struct MPL MPL;
32typedef char STRING;
33typedef struct SYMBOL SYMBOL;
34typedef struct TUPLE TUPLE;
35typedef struct ARRAY ELEMSET;
36typedef struct ELEMVAR ELEMVAR;
37typedef struct FORMULA FORMULA;
38typedef struct ELEMCON ELEMCON;
39typedef union VALUE VALUE;
40typedef struct ARRAY ARRAY;
41typedef struct MEMBER MEMBER;
42#if 1
43/* many C compilers have DOMAIN declared in <math.h> :( */
44#undef DOMAIN
45#define DOMAIN DOMAIN1
46#endif
47typedef struct DOMAIN DOMAIN;
48typedef struct DOMAIN_BLOCK DOMAIN_BLOCK;
49typedef struct DOMAIN_SLOT DOMAIN_SLOT;
50typedef struct SET SET;
51typedef struct WITHIN WITHIN;
52typedef struct GADGET GADGET;
53typedef struct PARAMETER PARAMETER;
54typedef struct CONDITION CONDITION;
55typedef struct VARIABLE VARIABLE;
56typedef struct CONSTRAINT CONSTRAINT;
57typedef struct TABLE TABLE;
58typedef struct TABARG TABARG;
59typedef struct TABFLD TABFLD;
60typedef struct TABIN TABIN;
61typedef struct TABOUT TABOUT;
62typedef struct TABDCA TABDCA;
63typedef union OPERANDS OPERANDS;
64typedef struct ARG_LIST ARG_LIST;
65typedef struct CODE CODE;
66typedef struct CHECK CHECK;
67typedef struct DISPLAY DISPLAY;
68typedef struct DISPLAY1 DISPLAY1;
69typedef struct PRINTF PRINTF;
70typedef struct PRINTF1 PRINTF1;
71typedef struct FOR FOR;
72typedef struct STATEMENT STATEMENT;
73typedef struct TUPLE SLICE;
74
75/**********************************************************************/
76/* * *                    TRANSLATOR DATABASE                     * * */
77/**********************************************************************/
78
79#define A_BINARY        101   /* something binary */
80#define A_CHECK         102   /* check statement */
81#define A_CONSTRAINT    103   /* model constraint */
82#define A_DISPLAY       104   /* display statement */
83#define A_ELEMCON       105   /* elemental constraint/objective */
84#define A_ELEMSET       106   /* elemental set */
85#define A_ELEMVAR       107   /* elemental variable */
86#define A_EXPRESSION    108   /* expression */
87#define A_FOR           109   /* for statement */
88#define A_FORMULA       110   /* formula */
89#define A_INDEX         111   /* dummy index */
90#define A_INPUT         112   /* input table */
91#define A_INTEGER       113   /* something integer */
92#define A_LOGICAL       114   /* something logical */
93#define A_MAXIMIZE      115   /* objective has to be maximized */
94#define A_MINIMIZE      116   /* objective has to be minimized */
95#define A_NONE          117   /* nothing */
96#define A_NUMERIC       118   /* something numeric */
97#define A_OUTPUT        119   /* output table */
98#define A_PARAMETER     120   /* model parameter */
99#define A_PRINTF        121   /* printf statement */
100#define A_SET           122   /* model set */
101#define A_SOLVE         123   /* solve statement */
102#define A_SYMBOLIC      124   /* something symbolic */
103#define A_TABLE         125   /* data table */
104#define A_TUPLE         126   /* n-tuple */
105#define A_VARIABLE      127   /* model variable */
106
107#define MAX_LENGTH 100
108/* maximal length of any symbolic value (this includes symbolic names,
109   numeric and string literals, and all symbolic values that may appear
110   during the evaluation phase) */
111
112#define CONTEXT_SIZE 60
113/* size of the context queue, in characters */
114
115#define OUTBUF_SIZE 1024
116/* size of the output buffer, in characters */
117
118struct MPL
119{     /* translator database */
120      /*--------------------------------------------------------------*/
121      /* scanning segment */
122      int line;
123      /* number of the current text line */
124      int c;
125      /* the current character or EOF */
126      int token;
127      /* the current token: */
128#define T_EOF           201   /* end of file */
129#define T_NAME          202   /* symbolic name (model section only) */
130#define T_SYMBOL        203   /* symbol (data section only) */
131#define T_NUMBER        204   /* numeric literal */
132#define T_STRING        205   /* string literal */
133#define T_AND           206   /* and && */
134#define T_BY            207   /* by */
135#define T_CROSS         208   /* cross */
136#define T_DIFF          209   /* diff */
137#define T_DIV           210   /* div */
138#define T_ELSE          211   /* else */
139#define T_IF            212   /* if */
140#define T_IN            213   /* in */
141#define T_INFINITY      214   /* Infinity */
142#define T_INTER         215   /* inter */
143#define T_LESS          216   /* less */
144#define T_MOD           217   /* mod */
145#define T_NOT           218   /* not ! */
146#define T_OR            219   /* or || */
147#define T_SPTP          220   /* s.t. */
148#define T_SYMDIFF       221   /* symdiff */
149#define T_THEN          222   /* then */
150#define T_UNION         223   /* union */
151#define T_WITHIN        224   /* within */
152#define T_PLUS          225   /* + */
153#define T_MINUS         226   /* - */
154#define T_ASTERISK      227   /* * */
155#define T_SLASH         228   /* / */
156#define T_POWER         229   /* ^ ** */
157#define T_LT            230   /* <  */
158#define T_LE            231   /* <= */
159#define T_EQ            232   /* = == */
160#define T_GE            233   /* >= */
161#define T_GT            234   /* >  */
162#define T_NE            235   /* <> != */
163#define T_CONCAT        236   /* & */
164#define T_BAR           237   /* | */
165#define T_POINT         238   /* . */
166#define T_COMMA         239   /* , */
167#define T_COLON         240   /* : */
168#define T_SEMICOLON     241   /* ; */
169#define T_ASSIGN        242   /* := */
170#define T_DOTS          243   /* .. */
171#define T_LEFT          244   /* ( */
172#define T_RIGHT         245   /* ) */
173#define T_LBRACKET      246   /* [ */
174#define T_RBRACKET      247   /* ] */
175#define T_LBRACE        248   /* { */
176#define T_RBRACE        249   /* } */
177#define T_APPEND        250   /* >> */
178#define T_TILDE         251   /* ~ */
179#define T_INPUT         252   /* <- */
180      int imlen;
181      /* length of the current token */
182      char *image; /* char image[MAX_LENGTH+1]; */
183      /* image of the current token */
184      double value;
185      /* value of the current token (for T_NUMBER only) */
186      int b_token;
187      /* the previous token */
188      int b_imlen;
189      /* length of the previous token */
190      char *b_image; /* char b_image[MAX_LENGTH+1]; */
191      /* image of the previous token */
192      double b_value;
193      /* value of the previous token (if token is T_NUMBER) */
194      int f_dots;
195      /* if this flag is set, the next token should be recognized as
196         T_DOTS, not as T_POINT */
197      int f_scan;
198      /* if this flag is set, the next token is already scanned */
199      int f_token;
200      /* the next token */
201      int f_imlen;
202      /* length of the next token */
203      char *f_image; /* char f_image[MAX_LENGTH+1]; */
204      /* image of the next token */
205      double f_value;
206      /* value of the next token (if token is T_NUMBER) */
207      char *context; /* char context[CONTEXT_SIZE]; */
208      /* context circular queue (not null-terminated!) */
209      int c_ptr;
210      /* pointer to the current position in the context queue */
211      int flag_d;
212      /* if this flag is set, the data section is being processed */
213      /*--------------------------------------------------------------*/
214      /* translating segment */
215      DMP *pool;
216      /* memory pool used to allocate all data instances created during
217         the translation phase */
218      AVL *tree;
219      /* symbolic name table:
220         node.type = A_INDEX     => node.link -> DOMAIN_SLOT
221         node.type = A_SET       => node.link -> SET
222         node.type = A_PARAMETER => node.link -> PARAMETER
223         node.type = A_VARIABLE  => node.link -> VARIABLE
224         node.type = A_CONSTRANT => node.link -> CONSTRAINT */
225      STATEMENT *model;
226      /* linked list of model statements in the original order */
227      int flag_x;
228      /* if this flag is set, the current token being left parenthesis
229         begins a slice that allows recognizing any undeclared symbolic
230         names as dummy indices; this flag is automatically reset once
231         the next token has been scanned */
232      int as_within;
233      /* the warning "in understood as within" has been issued */
234      int as_in;
235      /* the warning "within understood as in" has been issued */
236      int as_binary;
237      /* the warning "logical understood as binary" has been issued */
238      int flag_s;
239      /* if this flag is set, the solve statement has been parsed */
240      /*--------------------------------------------------------------*/
241      /* common segment */
242      DMP *strings;
243      /* memory pool to allocate STRING data structures */
244      DMP *symbols;
245      /* memory pool to allocate SYMBOL data structures */
246      DMP *tuples;
247      /* memory pool to allocate TUPLE data structures */
248      DMP *arrays;
249      /* memory pool to allocate ARRAY data structures */
250      DMP *members;
251      /* memory pool to allocate MEMBER data structures */
252      DMP *elemvars;
253      /* memory pool to allocate ELEMVAR data structures */
254      DMP *formulae;
255      /* memory pool to allocate FORMULA data structures */
256      DMP *elemcons;
257      /* memory pool to allocate ELEMCON data structures */
258      ARRAY *a_list;
259      /* linked list of all arrays in the database */
260      char *sym_buf; /* char sym_buf[255+1]; */
261      /* working buffer used by the routine format_symbol */
262      char *tup_buf; /* char tup_buf[255+1]; */
263      /* working buffer used by the routine format_tuple */
264      /*--------------------------------------------------------------*/
265      /* generating/postsolving segment */
266      RNG *rand;
267      /* pseudo-random number generator */
268      int flag_p;
269      /* if this flag is set, the postsolving phase is in effect */
270      STATEMENT *stmt;
271      /* model statement being currently executed */
272      TABDCA *dca;
273      /* pointer to table driver communication area for table statement
274         currently executed */
275      int m;
276      /* number of rows in the problem, m >= 0 */
277      int n;
278      /* number of columns in the problem, n >= 0 */
279      ELEMCON **row; /* ELEMCON *row[1+m]; */
280      /* row[0] is not used;
281         row[i] is elemental constraint or objective, which corresponds
282         to i-th row of the problem, 1 <= i <= m */
283      ELEMVAR **col; /* ELEMVAR *col[1+n]; */
284      /* col[0] is not used;
285         col[j] is elemental variable, which corresponds to j-th column
286         of the problem, 1 <= j <= n */
287      /*--------------------------------------------------------------*/
288      /* input/output segment */
289      XFILE *in_fp;
290      /* stream assigned to the input text file */
291      char *in_file;
292      /* name of the input text file */
293      XFILE *out_fp;
294      /* stream assigned to the output text file used to write all data
295         produced by display and printf statements; NULL means the data
296         should be sent to stdout via the routine xprintf */
297      char *out_file;
298      /* name of the output text file */
299#if 0 /* 08/XI-2009 */
300      char *out_buf; /* char out_buf[OUTBUF_SIZE] */
301      /* buffer to accumulate output data */
302      int out_cnt;
303      /* count of data bytes stored in the output buffer */
304#endif
305      XFILE *prt_fp;
306      /* stream assigned to the print text file; may be NULL */
307      char *prt_file;
308      /* name of the output print file */
309      /*--------------------------------------------------------------*/
310      /* solver interface segment */
311      jmp_buf jump;
312      /* jump address for non-local go to in case of error */
313      int phase;
314      /* phase of processing:
315         0 - database is being or has been initialized
316         1 - model section is being or has been read
317         2 - data section is being or has been read
318         3 - model is being or has been generated/postsolved
319         4 - model processing error has occurred */
320      char *mod_file;
321      /* name of the input text file, which contains model section */
322      char *mpl_buf; /* char mpl_buf[255+1]; */
323      /* working buffer used by some interface routines */
324};
325
326/**********************************************************************/
327/* * *                  PROCESSING MODEL SECTION                  * * */
328/**********************************************************************/
329
330#define alloc(type) ((type *)dmp_get_atomv(mpl->pool, sizeof(type)))
331/* allocate atom of given type */
332
333#define enter_context _glp_mpl_enter_context
334void enter_context(MPL *mpl);
335/* enter current token into context queue */
336
337#define print_context _glp_mpl_print_context
338void print_context(MPL *mpl);
339/* print current content of context queue */
340
341#define get_char _glp_mpl_get_char
342void get_char(MPL *mpl);
343/* scan next character from input text file */
344
345#define append_char _glp_mpl_append_char
346void append_char(MPL *mpl);
347/* append character to current token */
348
349#define get_token _glp_mpl_get_token
350void get_token(MPL *mpl);
351/* scan next token from input text file */
352
353#define unget_token _glp_mpl_unget_token
354void unget_token(MPL *mpl);
355/* return current token back to input stream */
356
357#define is_keyword _glp_mpl_is_keyword
358int is_keyword(MPL *mpl, char *keyword);
359/* check if current token is given non-reserved keyword */
360
361#define is_reserved _glp_mpl_is_reserved
362int is_reserved(MPL *mpl);
363/* check if current token is reserved keyword */
364
365#define make_code _glp_mpl_make_code
366CODE *make_code(MPL *mpl, int op, OPERANDS *arg, int type, int dim);
367/* generate pseudo-code (basic routine) */
368
369#define make_unary _glp_mpl_make_unary
370CODE *make_unary(MPL *mpl, int op, CODE *x, int type, int dim);
371/* generate pseudo-code for unary operation */
372
373#define make_binary _glp_mpl_make_binary
374CODE *make_binary(MPL *mpl, int op, CODE *x, CODE *y, int type,
375      int dim);
376/* generate pseudo-code for binary operation */
377
378#define make_ternary _glp_mpl_make_ternary
379CODE *make_ternary(MPL *mpl, int op, CODE *x, CODE *y, CODE *z,
380      int type, int dim);
381/* generate pseudo-code for ternary operation */
382
383#define numeric_literal _glp_mpl_numeric_literal
384CODE *numeric_literal(MPL *mpl);
385/* parse reference to numeric literal */
386
387#define string_literal _glp_mpl_string_literal
388CODE *string_literal(MPL *mpl);
389/* parse reference to string literal */
390
391#define create_arg_list _glp_mpl_create_arg_list
392ARG_LIST *create_arg_list(MPL *mpl);
393/* create empty operands list */
394
395#define expand_arg_list _glp_mpl_expand_arg_list
396ARG_LIST *expand_arg_list(MPL *mpl, ARG_LIST *list, CODE *x);
397/* append operand to operands list */
398
399#define arg_list_len _glp_mpl_arg_list_len
400int arg_list_len(MPL *mpl, ARG_LIST *list);
401/* determine length of operands list */
402
403#define subscript_list _glp_mpl_subscript_list
404ARG_LIST *subscript_list(MPL *mpl);
405/* parse subscript list */
406
407#define object_reference _glp_mpl_object_reference
408CODE *object_reference(MPL *mpl);
409/* parse reference to named object */
410
411#define numeric_argument _glp_mpl_numeric_argument
412CODE *numeric_argument(MPL *mpl, char *func);
413/* parse argument passed to built-in function */
414
415#define symbolic_argument _glp_mpl_symbolic_argument
416CODE *symbolic_argument(MPL *mpl, char *func);
417
418#define elemset_argument _glp_mpl_elemset_argument
419CODE *elemset_argument(MPL *mpl, char *func);
420
421#define function_reference _glp_mpl_function_reference
422CODE *function_reference(MPL *mpl);
423/* parse reference to built-in function */
424
425#define create_domain _glp_mpl_create_domain
426DOMAIN *create_domain(MPL *mpl);
427/* create empty domain */
428
429#define create_block _glp_mpl_create_block
430DOMAIN_BLOCK *create_block(MPL *mpl);
431/* create empty domain block */
432
433#define append_block _glp_mpl_append_block
434void append_block(MPL *mpl, DOMAIN *domain, DOMAIN_BLOCK *block);
435/* append domain block to specified domain */
436
437#define append_slot _glp_mpl_append_slot
438DOMAIN_SLOT *append_slot(MPL *mpl, DOMAIN_BLOCK *block, char *name,
439      CODE *code);
440/* create and append new slot to domain block */
441
442#define expression_list _glp_mpl_expression_list
443CODE *expression_list(MPL *mpl);
444/* parse expression list */
445
446#define literal_set _glp_mpl_literal_set
447CODE *literal_set(MPL *mpl, CODE *code);
448/* parse literal set */
449
450#define indexing_expression _glp_mpl_indexing_expression
451DOMAIN *indexing_expression(MPL *mpl);
452/* parse indexing expression */
453
454#define close_scope _glp_mpl_close_scope
455void close_scope(MPL *mpl, DOMAIN *domain);
456/* close scope of indexing expression */
457
458#define iterated_expression _glp_mpl_iterated_expression
459CODE *iterated_expression(MPL *mpl);
460/* parse iterated expression */
461
462#define domain_arity _glp_mpl_domain_arity
463int domain_arity(MPL *mpl, DOMAIN *domain);
464/* determine arity of domain */
465
466#define set_expression _glp_mpl_set_expression
467CODE *set_expression(MPL *mpl);
468/* parse set expression */
469
470#define branched_expression _glp_mpl_branched_expression
471CODE *branched_expression(MPL *mpl);
472/* parse conditional expression */
473
474#define primary_expression _glp_mpl_primary_expression
475CODE *primary_expression(MPL *mpl);
476/* parse primary expression */
477
478#define error_preceding _glp_mpl_error_preceding
479void error_preceding(MPL *mpl, char *opstr);
480/* raise error if preceding operand has wrong type */
481
482#define error_following _glp_mpl_error_following
483void error_following(MPL *mpl, char *opstr);
484/* raise error if following operand has wrong type */
485
486#define error_dimension _glp_mpl_error_dimension
487void error_dimension(MPL *mpl, char *opstr, int dim1, int dim2);
488/* raise error if operands have different dimension */
489
490#define expression_0 _glp_mpl_expression_0
491CODE *expression_0(MPL *mpl);
492/* parse expression of level 0 */
493
494#define expression_1 _glp_mpl_expression_1
495CODE *expression_1(MPL *mpl);
496/* parse expression of level 1 */
497
498#define expression_2 _glp_mpl_expression_2
499CODE *expression_2(MPL *mpl);
500/* parse expression of level 2 */
501
502#define expression_3 _glp_mpl_expression_3
503CODE *expression_3(MPL *mpl);
504/* parse expression of level 3 */
505
506#define expression_4 _glp_mpl_expression_4
507CODE *expression_4(MPL *mpl);
508/* parse expression of level 4 */
509
510#define expression_5 _glp_mpl_expression_5
511CODE *expression_5(MPL *mpl);
512/* parse expression of level 5 */
513
514#define expression_6 _glp_mpl_expression_6
515CODE *expression_6(MPL *mpl);
516/* parse expression of level 6 */
517
518#define expression_7 _glp_mpl_expression_7
519CODE *expression_7(MPL *mpl);
520/* parse expression of level 7 */
521
522#define expression_8 _glp_mpl_expression_8
523CODE *expression_8(MPL *mpl);
524/* parse expression of level 8 */
525
526#define expression_9 _glp_mpl_expression_9
527CODE *expression_9(MPL *mpl);
528/* parse expression of level 9 */
529
530#define expression_10 _glp_mpl_expression_10
531CODE *expression_10(MPL *mpl);
532/* parse expression of level 10 */
533
534#define expression_11 _glp_mpl_expression_11
535CODE *expression_11(MPL *mpl);
536/* parse expression of level 11 */
537
538#define expression_12 _glp_mpl_expression_12
539CODE *expression_12(MPL *mpl);
540/* parse expression of level 12 */
541
542#define expression_13 _glp_mpl_expression_13
543CODE *expression_13(MPL *mpl);
544/* parse expression of level 13 */
545
546#define set_statement _glp_mpl_set_statement
547SET *set_statement(MPL *mpl);
548/* parse set statement */
549
550#define parameter_statement _glp_mpl_parameter_statement
551PARAMETER *parameter_statement(MPL *mpl);
552/* parse parameter statement */
553
554#define variable_statement _glp_mpl_variable_statement
555VARIABLE *variable_statement(MPL *mpl);
556/* parse variable statement */
557
558#define constraint_statement _glp_mpl_constraint_statement
559CONSTRAINT *constraint_statement(MPL *mpl);
560/* parse constraint statement */
561
562#define objective_statement _glp_mpl_objective_statement
563CONSTRAINT *objective_statement(MPL *mpl);
564/* parse objective statement */
565
566#define table_statement _glp_mpl_table_statement
567TABLE *table_statement(MPL *mpl);
568/* parse table statement */
569
570#define solve_statement _glp_mpl_solve_statement
571void *solve_statement(MPL *mpl);
572/* parse solve statement */
573
574#define check_statement _glp_mpl_check_statement
575CHECK *check_statement(MPL *mpl);
576/* parse check statement */
577
578#define display_statement _glp_mpl_display_statement
579DISPLAY *display_statement(MPL *mpl);
580/* parse display statement */
581
582#define printf_statement _glp_mpl_printf_statement
583PRINTF *printf_statement(MPL *mpl);
584/* parse printf statement */
585
586#define for_statement _glp_mpl_for_statement
587FOR *for_statement(MPL *mpl);
588/* parse for statement */
589
590#define end_statement _glp_mpl_end_statement
591void end_statement(MPL *mpl);
592/* parse end statement */
593
594#define simple_statement _glp_mpl_simple_statement
595STATEMENT *simple_statement(MPL *mpl, int spec);
596/* parse simple statement */
597
598#define model_section _glp_mpl_model_section
599void model_section(MPL *mpl);
600/* parse model section */
601
602/**********************************************************************/
603/* * *                  PROCESSING DATA SECTION                   * * */
604/**********************************************************************/
605
606#if 2 + 2 == 5
607struct SLICE /* see TUPLE */
608{     /* component of slice; the slice itself is associated with its
609         first component; slices are similar to n-tuples with exception
610         that some slice components (which are indicated by asterisks)
611         don't refer to any symbols */
612      SYMBOL *sym;
613      /* symbol, which this component refers to; can be NULL */
614      SLICE *next;
615      /* the next component of slice */
616};
617#endif
618
619#define create_slice _glp_mpl_create_slice
620SLICE *create_slice(MPL *mpl);
621/* create slice */
622
623#define expand_slice _glp_mpl_expand_slice
624SLICE *expand_slice
625(     MPL *mpl,
626      SLICE *slice,           /* destroyed */
627      SYMBOL *sym             /* destroyed */
628);
629/* append new component to slice */
630
631#define slice_dimen _glp_mpl_slice_dimen
632int slice_dimen
633(     MPL *mpl,
634      SLICE *slice            /* not changed */
635);
636/* determine dimension of slice */
637
638#define slice_arity _glp_mpl_slice_arity
639int slice_arity
640(     MPL *mpl,
641      SLICE *slice            /* not changed */
642);
643/* determine arity of slice */
644
645#define fake_slice _glp_mpl_fake_slice
646SLICE *fake_slice(MPL *mpl, int dim);
647/* create fake slice of all asterisks */
648
649#define delete_slice _glp_mpl_delete_slice
650void delete_slice
651(     MPL *mpl,
652      SLICE *slice            /* destroyed */
653);
654/* delete slice */
655
656#define is_number _glp_mpl_is_number
657int is_number(MPL *mpl);
658/* check if current token is number */
659
660#define is_symbol _glp_mpl_is_symbol
661int is_symbol(MPL *mpl);
662/* check if current token is symbol */
663
664#define is_literal _glp_mpl_is_literal
665int is_literal(MPL *mpl, char *literal);
666/* check if current token is given symbolic literal */
667
668#define read_number _glp_mpl_read_number
669double read_number(MPL *mpl);
670/* read number */
671
672#define read_symbol _glp_mpl_read_symbol
673SYMBOL *read_symbol(MPL *mpl);
674/* read symbol */
675
676#define read_slice _glp_mpl_read_slice
677SLICE *read_slice
678(     MPL *mpl,
679      char *name,             /* not changed */
680      int dim
681);
682/* read slice */
683
684#define select_set _glp_mpl_select_set
685SET *select_set
686(     MPL *mpl,
687      char *name              /* not changed */
688);
689/* select set to saturate it with elemental sets */
690
691#define simple_format _glp_mpl_simple_format
692void simple_format
693(     MPL *mpl,
694      SET *set,               /* not changed */
695      MEMBER *memb,           /* modified */
696      SLICE *slice            /* not changed */
697);
698/* read set data block in simple format */
699
700#define matrix_format _glp_mpl_matrix_format
701void matrix_format
702(     MPL *mpl,
703      SET *set,               /* not changed */
704      MEMBER *memb,           /* modified */
705      SLICE *slice,           /* not changed */
706      int tr
707);
708/* read set data block in matrix format */
709
710#define set_data _glp_mpl_set_data
711void set_data(MPL *mpl);
712/* read set data */
713
714#define select_parameter _glp_mpl_select_parameter
715PARAMETER *select_parameter
716(     MPL *mpl,
717      char *name              /* not changed */
718);
719/* select parameter to saturate it with data */
720
721#define set_default _glp_mpl_set_default
722void set_default
723(     MPL *mpl,
724      PARAMETER *par,         /* not changed */
725      SYMBOL *altval          /* destroyed */
726);
727/* set default parameter value */
728
729#define read_value _glp_mpl_read_value
730MEMBER *read_value
731(     MPL *mpl,
732      PARAMETER *par,         /* not changed */
733      TUPLE *tuple            /* destroyed */
734);
735/* read value and assign it to parameter member */
736
737#define plain_format _glp_mpl_plain_format
738void plain_format
739(     MPL *mpl,
740      PARAMETER *par,         /* not changed */
741      SLICE *slice            /* not changed */
742);
743/* read parameter data block in plain format */
744
745#define tabular_format _glp_mpl_tabular_format
746void tabular_format
747(     MPL *mpl,
748      PARAMETER *par,         /* not changed */
749      SLICE *slice,           /* not changed */
750      int tr
751);
752/* read parameter data block in tabular format */
753
754#define tabbing_format _glp_mpl_tabbing_format
755void tabbing_format
756(     MPL *mpl,
757      SYMBOL *altval          /* not changed */
758);
759/* read parameter data block in tabbing format */
760
761#define parameter_data _glp_mpl_parameter_data
762void parameter_data(MPL *mpl);
763/* read parameter data */
764
765#define data_section _glp_mpl_data_section
766void data_section(MPL *mpl);
767/* read data section */
768
769/**********************************************************************/
770/* * *                   FLOATING-POINT NUMBERS                   * * */
771/**********************************************************************/
772
773#define fp_add _glp_mpl_fp_add
774double fp_add(MPL *mpl, double x, double y);
775/* floating-point addition */
776
777#define fp_sub _glp_mpl_fp_sub
778double fp_sub(MPL *mpl, double x, double y);
779/* floating-point subtraction */
780
781#define fp_less _glp_mpl_fp_less
782double fp_less(MPL *mpl, double x, double y);
783/* floating-point non-negative subtraction */
784
785#define fp_mul _glp_mpl_fp_mul
786double fp_mul(MPL *mpl, double x, double y);
787/* floating-point multiplication */
788
789#define fp_div _glp_mpl_fp_div
790double fp_div(MPL *mpl, double x, double y);
791/* floating-point division */
792
793#define fp_idiv _glp_mpl_fp_idiv
794double fp_idiv(MPL *mpl, double x, double y);
795/* floating-point quotient of exact division */
796
797#define fp_mod _glp_mpl_fp_mod
798double fp_mod(MPL *mpl, double x, double y);
799/* floating-point remainder of exact division */
800
801#define fp_power _glp_mpl_fp_power
802double fp_power(MPL *mpl, double x, double y);
803/* floating-point exponentiation (raise to power) */
804
805#define fp_exp _glp_mpl_fp_exp
806double fp_exp(MPL *mpl, double x);
807/* floating-point base-e exponential */
808
809#define fp_log _glp_mpl_fp_log
810double fp_log(MPL *mpl, double x);
811/* floating-point natural logarithm */
812
813#define fp_log10 _glp_mpl_fp_log10
814double fp_log10(MPL *mpl, double x);
815/* floating-point common (decimal) logarithm */
816
817#define fp_sqrt _glp_mpl_fp_sqrt
818double fp_sqrt(MPL *mpl, double x);
819/* floating-point square root */
820
821#define fp_sin _glp_mpl_fp_sin
822double fp_sin(MPL *mpl, double x);
823/* floating-point trigonometric sine */
824
825#define fp_cos _glp_mpl_fp_cos
826double fp_cos(MPL *mpl, double x);
827/* floating-point trigonometric cosine */
828
829#define fp_atan _glp_mpl_fp_atan
830double fp_atan(MPL *mpl, double x);
831/* floating-point trigonometric arctangent */
832
833#define fp_atan2 _glp_mpl_fp_atan2
834double fp_atan2(MPL *mpl, double y, double x);
835/* floating-point trigonometric arctangent */
836
837#define fp_round _glp_mpl_fp_round
838double fp_round(MPL *mpl, double x, double n);
839/* round floating-point value to n fractional digits */
840
841#define fp_trunc _glp_mpl_fp_trunc
842double fp_trunc(MPL *mpl, double x, double n);
843/* truncate floating-point value to n fractional digits */
844
845/**********************************************************************/
846/* * *              PSEUDO-RANDOM NUMBER GENERATORS               * * */
847/**********************************************************************/
848
849#define fp_irand224 _glp_mpl_fp_irand224
850double fp_irand224(MPL *mpl);
851/* pseudo-random integer in the range [0, 2^24) */
852
853#define fp_uniform01 _glp_mpl_fp_uniform01
854double fp_uniform01(MPL *mpl);
855/* pseudo-random number in the range [0, 1) */
856
857#define fp_uniform _glp_mpl_uniform
858double fp_uniform(MPL *mpl, double a, double b);
859/* pseudo-random number in the range [a, b) */
860
861#define fp_normal01 _glp_mpl_fp_normal01
862double fp_normal01(MPL *mpl);
863/* Gaussian random variate with mu = 0 and sigma = 1 */
864
865#define fp_normal _glp_mpl_fp_normal
866double fp_normal(MPL *mpl, double mu, double sigma);
867/* Gaussian random variate with specified mu and sigma */
868
869/**********************************************************************/
870/* * *                         DATE/TIME                          * * */
871/**********************************************************************/
872
873#define fn_gmtime _glp_mpl_fn_gmtime
874double fn_gmtime(MPL *mpl);
875/* obtain the current calendar time (UTC) */
876
877#define fn_str2time _glp_mpl_fn_str2time
878double fn_str2time(MPL *mpl, const char *str, const char *fmt);
879/* convert character string to the calendar time */
880
881#define fn_time2str _glp_mpl_fn_time2str
882void fn_time2str(MPL *mpl, char *str, double t, const char *fmt);
883/* convert the calendar time to character string */
884
885/**********************************************************************/
886/* * *                     CHARACTER STRINGS                      * * */
887/**********************************************************************/
888
889#define create_string _glp_mpl_create_string
890STRING *create_string
891(     MPL *mpl,
892      char buf[MAX_LENGTH+1]  /* not changed */
893);
894/* create character string */
895
896#define copy_string _glp_mpl_copy_string
897STRING *copy_string
898(     MPL *mpl,
899      STRING *str             /* not changed */
900);
901/* make copy of character string */
902
903#define compare_strings _glp_mpl_compare_strings
904int compare_strings
905(     MPL *mpl,
906      STRING *str1,           /* not changed */
907      STRING *str2            /* not changed */
908);
909/* compare one character string with another */
910
911#define fetch_string _glp_mpl_fetch_string
912char *fetch_string
913(     MPL *mpl,
914      STRING *str,            /* not changed */
915      char buf[MAX_LENGTH+1]  /* modified */
916);
917/* extract content of character string */
918
919#define delete_string _glp_mpl_delete_string
920void delete_string
921(     MPL *mpl,
922      STRING *str             /* destroyed */
923);
924/* delete character string */
925
926/**********************************************************************/
927/* * *                          SYMBOLS                           * * */
928/**********************************************************************/
929
930struct SYMBOL
931{     /* symbol (numeric or abstract quantity) */
932      double num;
933      /* numeric value of symbol (used only if str == NULL) */
934      STRING *str;
935      /* abstract value of symbol (used only if str != NULL) */
936};
937
938#define create_symbol_num _glp_mpl_create_symbol_num
939SYMBOL *create_symbol_num(MPL *mpl, double num);
940/* create symbol of numeric type */
941
942#define create_symbol_str _glp_mpl_create_symbol_str
943SYMBOL *create_symbol_str
944(     MPL *mpl,
945      STRING *str             /* destroyed */
946);
947/* create symbol of abstract type */
948
949#define copy_symbol _glp_mpl_copy_symbol
950SYMBOL *copy_symbol
951(     MPL *mpl,
952      SYMBOL *sym             /* not changed */
953);
954/* make copy of symbol */
955
956#define compare_symbols _glp_mpl_compare_symbols
957int compare_symbols
958(     MPL *mpl,
959      SYMBOL *sym1,           /* not changed */
960      SYMBOL *sym2            /* not changed */
961);
962/* compare one symbol with another */
963
964#define delete_symbol _glp_mpl_delete_symbol
965void delete_symbol
966(     MPL *mpl,
967      SYMBOL *sym             /* destroyed */
968);
969/* delete symbol */
970
971#define format_symbol _glp_mpl_format_symbol
972char *format_symbol
973(     MPL *mpl,
974      SYMBOL *sym             /* not changed */
975);
976/* format symbol for displaying or printing */
977
978#define concat_symbols _glp_mpl_concat_symbols
979SYMBOL *concat_symbols
980(     MPL *mpl,
981      SYMBOL *sym1,           /* destroyed */
982      SYMBOL *sym2            /* destroyed */
983);
984/* concatenate one symbol with another */
985
986/**********************************************************************/
987/* * *                          N-TUPLES                          * * */
988/**********************************************************************/
989
990struct TUPLE
991{     /* component of n-tuple; the n-tuple itself is associated with
992         its first component; (note that 0-tuple has no components) */
993      SYMBOL *sym;
994      /* symbol, which the component refers to; cannot be NULL */
995      TUPLE *next;
996      /* the next component of n-tuple */
997};
998
999#define create_tuple _glp_mpl_create_tuple
1000TUPLE *create_tuple(MPL *mpl);
1001/* create n-tuple */
1002
1003#define expand_tuple _glp_mpl_expand_tuple
1004TUPLE *expand_tuple
1005(     MPL *mpl,
1006      TUPLE *tuple,           /* destroyed */
1007      SYMBOL *sym             /* destroyed */
1008);
1009/* append symbol to n-tuple */
1010
1011#define tuple_dimen _glp_mpl_tuple_dimen
1012int tuple_dimen
1013(     MPL *mpl,
1014      TUPLE *tuple            /* not changed */
1015);
1016/* determine dimension of n-tuple */
1017
1018#define copy_tuple _glp_mpl_copy_tuple
1019TUPLE *copy_tuple
1020(     MPL *mpl,
1021      TUPLE *tuple            /* not changed */
1022);
1023/* make copy of n-tuple */
1024
1025#define compare_tuples _glp_mpl_compare_tuples
1026int compare_tuples
1027(     MPL *mpl,
1028      TUPLE *tuple1,          /* not changed */
1029      TUPLE *tuple2           /* not changed */
1030);
1031/* compare one n-tuple with another */
1032
1033#define build_subtuple _glp_mpl_build_subtuple
1034TUPLE *build_subtuple
1035(     MPL *mpl,
1036      TUPLE *tuple,           /* not changed */
1037      int dim
1038);
1039/* build subtuple of given n-tuple */
1040
1041#define delete_tuple _glp_mpl_delete_tuple
1042void delete_tuple
1043(     MPL *mpl,
1044      TUPLE *tuple            /* destroyed */
1045);
1046/* delete n-tuple */
1047
1048#define format_tuple _glp_mpl_format_tuple
1049char *format_tuple
1050(     MPL *mpl,
1051      int c,
1052      TUPLE *tuple            /* not changed */
1053);
1054/* format n-tuple for displaying or printing */
1055
1056/**********************************************************************/
1057/* * *                       ELEMENTAL SETS                       * * */
1058/**********************************************************************/
1059
1060#if 2 + 2 == 5
1061struct ELEMSET /* see ARRAY */
1062{     /* elemental set of n-tuples; formally it is a "value" assigned
1063         to members of model sets (like numbers and symbols, which are
1064         values assigned to members of model parameters); note that a
1065         simple model set is not an elemental set, it is 0-dimensional
1066         array, the only member of which (if it exists) is assigned an
1067         elemental set */
1068#endif
1069
1070#define create_elemset _glp_mpl_create_elemset
1071ELEMSET *create_elemset(MPL *mpl, int dim);
1072/* create elemental set */
1073
1074#define find_tuple _glp_mpl_find_tuple
1075MEMBER *find_tuple
1076(     MPL *mpl,
1077      ELEMSET *set,           /* not changed */
1078      TUPLE *tuple            /* not changed */
1079);
1080/* check if elemental set contains given n-tuple */
1081
1082#define add_tuple _glp_mpl_add_tuple
1083MEMBER *add_tuple
1084(     MPL *mpl,
1085      ELEMSET *set,           /* modified */
1086      TUPLE *tuple            /* destroyed */
1087);
1088/* add new n-tuple to elemental set */
1089
1090#define check_then_add _glp_mpl_check_then_add
1091MEMBER *check_then_add
1092(     MPL *mpl,
1093      ELEMSET *set,           /* modified */
1094      TUPLE *tuple            /* destroyed */
1095);
1096/* check and add new n-tuple to elemental set */
1097
1098#define copy_elemset _glp_mpl_copy_elemset
1099ELEMSET *copy_elemset
1100(     MPL *mpl,
1101      ELEMSET *set            /* not changed */
1102);
1103/* make copy of elemental set */
1104
1105#define delete_elemset _glp_mpl_delete_elemset
1106void delete_elemset
1107(     MPL *mpl,
1108      ELEMSET *set            /* destroyed */
1109);
1110/* delete elemental set */
1111
1112#define arelset_size _glp_mpl_arelset_size
1113int arelset_size(MPL *mpl, double t0, double tf, double dt);
1114/* compute size of "arithmetic" elemental set */
1115
1116#define arelset_member _glp_mpl_arelset_member
1117double arelset_member(MPL *mpl, double t0, double tf, double dt, int j);
1118/* compute member of "arithmetic" elemental set */
1119
1120#define create_arelset _glp_mpl_create_arelset
1121ELEMSET *create_arelset(MPL *mpl, double t0, double tf, double dt);
1122/* create "arithmetic" elemental set */
1123
1124#define set_union _glp_mpl_set_union
1125ELEMSET *set_union
1126(     MPL *mpl,
1127      ELEMSET *X,             /* destroyed */
1128      ELEMSET *Y              /* destroyed */
1129);
1130/* union of two elemental sets */
1131
1132#define set_diff _glp_mpl_set_diff
1133ELEMSET *set_diff
1134(     MPL *mpl,
1135      ELEMSET *X,             /* destroyed */
1136      ELEMSET *Y              /* destroyed */
1137);
1138/* difference between two elemental sets */
1139
1140#define set_symdiff _glp_mpl_set_symdiff
1141ELEMSET *set_symdiff
1142(     MPL *mpl,
1143      ELEMSET *X,             /* destroyed */
1144      ELEMSET *Y              /* destroyed */
1145);
1146/* symmetric difference between two elemental sets */
1147
1148#define set_inter _glp_mpl_set_inter
1149ELEMSET *set_inter
1150(     MPL *mpl,
1151      ELEMSET *X,             /* destroyed */
1152      ELEMSET *Y              /* destroyed */
1153);
1154/* intersection of two elemental sets */
1155
1156#define set_cross _glp_mpl_set_cross
1157ELEMSET *set_cross
1158(     MPL *mpl,
1159      ELEMSET *X,             /* destroyed */
1160      ELEMSET *Y              /* destroyed */
1161);
1162/* cross (Cartesian) product of two elemental sets */
1163
1164/**********************************************************************/
1165/* * *                    ELEMENTAL VARIABLES                     * * */
1166/**********************************************************************/
1167
1168struct ELEMVAR
1169{     /* elemental variable; formally it is a "value" assigned to
1170         members of model variables (like numbers and symbols, which
1171         are values assigned to members of model parameters) */
1172      int j;
1173      /* LP column number assigned to this elemental variable */
1174      VARIABLE *var;
1175      /* model variable, which contains this elemental variable */
1176      MEMBER *memb;
1177      /* array member, which is assigned this elemental variable */
1178      double lbnd;
1179      /* lower bound */
1180      double ubnd;
1181      /* upper bound */
1182      double temp;
1183      /* working quantity used in operations on linear forms; normally
1184         it contains floating-point zero */
1185#if 1 /* 15/V-2010 */
1186      int stat;
1187      double prim, dual;
1188      /* solution components provided by the solver */
1189#endif
1190};
1191
1192/**********************************************************************/
1193/* * *                        LINEAR FORMS                        * * */
1194/**********************************************************************/
1195
1196struct FORMULA
1197{     /* term of linear form c * x, where c is a coefficient, x is an
1198         elemental variable; the linear form itself is the sum of terms
1199         and is associated with its first term; (note that the linear
1200         form may be empty that means the sum is equal to zero) */
1201      double coef;
1202      /* coefficient at elemental variable or constant term */
1203      ELEMVAR *var;
1204      /* reference to elemental variable; NULL means constant term */
1205      FORMULA *next;
1206      /* the next term of linear form */
1207};
1208
1209#define constant_term _glp_mpl_constant_term
1210FORMULA *constant_term(MPL *mpl, double coef);
1211/* create constant term */
1212
1213#define single_variable _glp_mpl_single_variable
1214FORMULA *single_variable
1215(     MPL *mpl,
1216      ELEMVAR *var            /* referenced */
1217);
1218/* create single variable */
1219
1220#define copy_formula _glp_mpl_copy_formula
1221FORMULA *copy_formula
1222(     MPL *mpl,
1223      FORMULA *form           /* not changed */
1224);
1225/* make copy of linear form */
1226
1227#define delete_formula _glp_mpl_delete_formula
1228void delete_formula
1229(     MPL *mpl,
1230      FORMULA *form           /* destroyed */
1231);
1232/* delete linear form */
1233
1234#define linear_comb _glp_mpl_linear_comb
1235FORMULA *linear_comb
1236(     MPL *mpl,
1237      double a, FORMULA *fx,  /* destroyed */
1238      double b, FORMULA *fy   /* destroyed */
1239);
1240/* linear combination of two linear forms */
1241
1242#define remove_constant _glp_mpl_remove_constant
1243FORMULA *remove_constant
1244(     MPL *mpl,
1245      FORMULA *form,          /* destroyed */
1246      double *coef            /* modified */
1247);
1248/* remove constant term from linear form */
1249
1250#define reduce_terms _glp_mpl_reduce_terms
1251FORMULA *reduce_terms
1252(     MPL *mpl,
1253      FORMULA *form           /* destroyed */
1254);
1255/* reduce identical terms in linear form */
1256
1257/**********************************************************************/
1258/* * *                   ELEMENTAL CONSTRAINTS                    * * */
1259/**********************************************************************/
1260
1261struct ELEMCON
1262{     /* elemental constraint; formally it is a "value" assigned to
1263         members of model constraints (like numbers or symbols, which
1264         are values assigned to members of model parameters) */
1265      int i;
1266      /* LP row number assigned to this elemental constraint */
1267      CONSTRAINT *con;
1268      /* model constraint, which contains this elemental constraint */
1269      MEMBER *memb;
1270      /* array member, which is assigned this elemental constraint */
1271      FORMULA *form;
1272      /* linear form */
1273      double lbnd;
1274      /* lower bound */
1275      double ubnd;
1276      /* upper bound */
1277#if 1 /* 15/V-2010 */
1278      int stat;
1279      double prim, dual;
1280      /* solution components provided by the solver */
1281#endif
1282};
1283
1284/**********************************************************************/
1285/* * *                       GENERIC VALUES                       * * */
1286/**********************************************************************/
1287
1288union VALUE
1289{     /* generic value, which can be assigned to object member or be a
1290         result of evaluation of expression */
1291      /* indicator that specifies the particular type of generic value
1292         is stored in the corresponding array or pseudo-code descriptor
1293         and can be one of the following:
1294         A_NONE     - no value
1295         A_NUMERIC  - floating-point number
1296         A_SYMBOLIC - symbol
1297         A_LOGICAL  - logical value
1298         A_TUPLE    - n-tuple
1299         A_ELEMSET  - elemental set
1300         A_ELEMVAR  - elemental variable
1301         A_FORMULA  - linear form
1302         A_ELEMCON  - elemental constraint */
1303      void *none;    /* null */
1304      double num;    /* value */
1305      SYMBOL *sym;   /* value */
1306      int bit;       /* value */
1307      TUPLE *tuple;  /* value */
1308      ELEMSET *set;  /* value */
1309      ELEMVAR *var;  /* reference */
1310      FORMULA *form; /* value */
1311      ELEMCON *con;  /* reference */
1312};
1313
1314#define delete_value _glp_mpl_delete_value
1315void delete_value
1316(     MPL *mpl,
1317      int type,
1318      VALUE *value            /* content destroyed */
1319);
1320/* delete generic value */
1321
1322/**********************************************************************/
1323/* * *                SYMBOLICALLY INDEXED ARRAYS                 * * */
1324/**********************************************************************/
1325
1326struct ARRAY
1327{     /* multi-dimensional array, a set of members indexed over simple
1328         or compound sets of symbols; arrays are used to represent the
1329         contents of model objects (i.e. sets, parameters, variables,
1330         constraints, and objectives); arrays also are used as "values"
1331         that are assigned to members of set objects, in which case the
1332         array itself represents an elemental set */
1333      int type;
1334      /* type of generic values assigned to the array members:
1335         A_NONE     - none (members have no assigned values)
1336         A_NUMERIC  - floating-point numbers
1337         A_SYMBOLIC - symbols
1338         A_ELEMSET  - elemental sets
1339         A_ELEMVAR  - elemental variables
1340         A_ELEMCON  - elemental constraints */
1341      int dim;
1342      /* dimension of the array that determines number of components in
1343         n-tuples for all members of the array, dim >= 0; dim = 0 means
1344         the array is 0-dimensional */
1345      int size;
1346      /* size of the array, i.e. number of its members */
1347      MEMBER *head;
1348      /* the first array member; NULL means the array is empty */
1349      MEMBER *tail;
1350      /* the last array member; NULL means the array is empty */
1351      AVL *tree;
1352      /* the search tree intended to find array members for logarithmic
1353         time; NULL means the search tree doesn't exist */
1354      ARRAY *prev;
1355      /* the previous array in the translator database */
1356      ARRAY *next;
1357      /* the next array in the translator database */
1358};
1359
1360struct MEMBER
1361{     /* array member */
1362      TUPLE *tuple;
1363      /* n-tuple, which identifies the member; number of its components
1364         is the same for all members within the array and determined by
1365         the array dimension; duplicate members are not allowed */
1366      MEMBER *next;
1367      /* the next array member */
1368      VALUE value;
1369      /* generic value assigned to the member */
1370};
1371
1372#define create_array _glp_mpl_create_array
1373ARRAY *create_array(MPL *mpl, int type, int dim);
1374/* create array */
1375
1376#define find_member _glp_mpl_find_member
1377MEMBER *find_member
1378(     MPL *mpl,
1379      ARRAY *array,           /* not changed */
1380      TUPLE *tuple            /* not changed */
1381);
1382/* find array member with given n-tuple */
1383
1384#define add_member _glp_mpl_add_member
1385MEMBER *add_member
1386(     MPL *mpl,
1387      ARRAY *array,           /* modified */
1388      TUPLE *tuple            /* destroyed */
1389);
1390/* add new member to array */
1391
1392#define delete_array _glp_mpl_delete_array
1393void delete_array
1394(     MPL *mpl,
1395      ARRAY *array            /* destroyed */
1396);
1397/* delete array */
1398
1399/**********************************************************************/
1400/* * *                 DOMAINS AND DUMMY INDICES                  * * */
1401/**********************************************************************/
1402
1403struct DOMAIN
1404{     /* domain (a simple or compound set); syntactically domain looks
1405         like '{ i in I, (j,k) in S, t in T : <predicate> }'; domains
1406         are used to define sets, over which model objects are indexed,
1407         and also as constituents of iterated operators */
1408      DOMAIN_BLOCK *list;
1409      /* linked list of domain blocks (in the example above such blocks
1410         are 'i in I', '(j,k) in S', and 't in T'); this list cannot be
1411         empty */
1412      CODE *code;
1413      /* pseudo-code for computing the logical predicate, which follows
1414         the colon; NULL means no predicate is specified */
1415};
1416
1417struct DOMAIN_BLOCK
1418{     /* domain block; syntactically domain blocks look like 'i in I',
1419         '(j,k) in S', and 't in T' in the example above (in the sequel
1420         sets like I, S, and T are called basic sets) */
1421      DOMAIN_SLOT *list;
1422      /* linked list of domain slots (i.e. indexing positions); number
1423         of slots in this list is the same as dimension of n-tuples in
1424         the basic set; this list cannot be empty */
1425      CODE *code;
1426      /* pseudo-code for computing basic set; cannot be NULL */
1427      TUPLE *backup;
1428      /* if this n-tuple is not empty, current values of dummy indices
1429         in the domain block are the same as components of this n-tuple
1430         (note that this n-tuple may have larger dimension than number
1431         of dummy indices in this block, in which case extra components
1432         are ignored); this n-tuple is used to restore former values of
1433         dummy indices, if they were changed due to recursive calls to
1434         the domain block */
1435      DOMAIN_BLOCK *next;
1436      /* the next block in the same domain */
1437};
1438
1439struct DOMAIN_SLOT
1440{     /* domain slot; it specifies an individual indexing position and
1441         defines the corresponding dummy index */
1442      char *name;
1443      /* symbolic name of the dummy index; null pointer means the dummy
1444         index is not explicitly specified */
1445      CODE *code;
1446      /* pseudo-code for computing symbolic value, at which the dummy
1447         index is bound; NULL means the dummy index is free within the
1448         domain scope */
1449      SYMBOL *value;
1450      /* current value assigned to the dummy index; NULL means no value
1451         is assigned at the moment */
1452      CODE *list;
1453      /* linked list of pseudo-codes with operation O_INDEX referring
1454         to this slot; this linked list is used to invalidate resultant
1455         values of the operation, which depend on this dummy index */
1456      DOMAIN_SLOT *next;
1457      /* the next slot in the same domain block */
1458};
1459
1460#define assign_dummy_index _glp_mpl_assign_dummy_index
1461void assign_dummy_index
1462(     MPL *mpl,
1463      DOMAIN_SLOT *slot,      /* modified */
1464      SYMBOL *value           /* not changed */
1465);
1466/* assign new value to dummy index */
1467
1468#define update_dummy_indices _glp_mpl_update_dummy_indices
1469void update_dummy_indices
1470(     MPL *mpl,
1471      DOMAIN_BLOCK *block     /* not changed */
1472);
1473/* update current values of dummy indices */
1474
1475#define enter_domain_block _glp_mpl_enter_domain_block
1476int enter_domain_block
1477(     MPL *mpl,
1478      DOMAIN_BLOCK *block,    /* not changed */
1479      TUPLE *tuple,           /* not changed */
1480      void *info, void (*func)(MPL *mpl, void *info)
1481);
1482/* enter domain block */
1483
1484#define eval_within_domain _glp_mpl_eval_within_domain
1485int eval_within_domain
1486(     MPL *mpl,
1487      DOMAIN *domain,         /* not changed */
1488      TUPLE *tuple,           /* not changed */
1489      void *info, void (*func)(MPL *mpl, void *info)
1490);
1491/* perform evaluation within domain scope */
1492
1493#define loop_within_domain _glp_mpl_loop_within_domain
1494void loop_within_domain
1495(     MPL *mpl,
1496      DOMAIN *domain,         /* not changed */
1497      void *info, int (*func)(MPL *mpl, void *info)
1498);
1499/* perform iterations within domain scope */
1500
1501#define out_of_domain _glp_mpl_out_of_domain
1502void out_of_domain
1503(     MPL *mpl,
1504      char *name,             /* not changed */
1505      TUPLE *tuple            /* not changed */
1506);
1507/* raise domain exception */
1508
1509#define get_domain_tuple _glp_mpl_get_domain_tuple
1510TUPLE *get_domain_tuple
1511(     MPL *mpl,
1512      DOMAIN *domain          /* not changed */
1513);
1514/* obtain current n-tuple from domain */
1515
1516#define clean_domain _glp_mpl_clean_domain
1517void clean_domain(MPL *mpl, DOMAIN *domain);
1518/* clean domain */
1519
1520/**********************************************************************/
1521/* * *                         MODEL SETS                         * * */
1522/**********************************************************************/
1523
1524struct SET
1525{     /* model set */
1526      char *name;
1527      /* symbolic name; cannot be NULL */
1528      char *alias;
1529      /* alias; NULL means alias is not specified */
1530      int dim; /* aka arity */
1531      /* dimension (number of subscripts); dim = 0 means 0-dimensional
1532         (unsubscripted) set, dim > 0 means set of sets */
1533      DOMAIN *domain;
1534      /* subscript domain; NULL for 0-dimensional set */
1535      int dimen;
1536      /* dimension of n-tuples, which members of this set consist of
1537         (note that the model set itself is an array of elemental sets,
1538         which are its members; so, don't confuse this dimension with
1539         dimension of the model set); always non-zero */
1540      WITHIN *within;
1541      /* list of supersets, which restrict each member of the set to be
1542         in every superset from this list; this list can be empty */
1543      CODE *assign;
1544      /* pseudo-code for computing assigned value; can be NULL */
1545      CODE *option;
1546      /* pseudo-code for computing default value; can be NULL */
1547      GADGET *gadget;
1548      /* plain set used to initialize the array of sets; can be NULL */
1549      int data;
1550      /* data status flag:
1551         0 - no data are provided in the data section
1552         1 - data are provided, but not checked yet
1553         2 - data are provided and have been checked */
1554      ARRAY *array;
1555      /* array of members, which are assigned elemental sets */
1556};
1557
1558struct WITHIN
1559{     /* restricting superset list entry */
1560      CODE *code;
1561      /* pseudo-code for computing the superset; cannot be NULL */
1562      WITHIN *next;
1563      /* the next entry for the same set or parameter */
1564};
1565
1566struct GADGET
1567{     /* plain set used to initialize the array of sets with data */
1568      SET *set;
1569      /* pointer to plain set; cannot be NULL */
1570      int ind[20]; /* ind[dim+dimen]; */
1571      /* permutation of integers 1, 2, ..., dim+dimen */
1572};
1573
1574#define check_elem_set _glp_mpl_check_elem_set
1575void check_elem_set
1576(     MPL *mpl,
1577      SET *set,               /* not changed */
1578      TUPLE *tuple,           /* not changed */
1579      ELEMSET *refer          /* not changed */
1580);
1581/* check elemental set assigned to set member */
1582
1583#define take_member_set _glp_mpl_take_member_set
1584ELEMSET *take_member_set      /* returns reference, not value */
1585(     MPL *mpl,
1586      SET *set,               /* not changed */
1587      TUPLE *tuple            /* not changed */
1588);
1589/* obtain elemental set assigned to set member */
1590
1591#define eval_member_set _glp_mpl_eval_member_set
1592ELEMSET *eval_member_set      /* returns reference, not value */
1593(     MPL *mpl,
1594      SET *set,               /* not changed */
1595      TUPLE *tuple            /* not changed */
1596);
1597/* evaluate elemental set assigned to set member */
1598
1599#define eval_whole_set _glp_mpl_eval_whole_set
1600void eval_whole_set(MPL *mpl, SET *set);
1601/* evaluate model set over entire domain */
1602
1603#define clean_set _glp_mpl_clean_set
1604void clean_set(MPL *mpl, SET *set);
1605/* clean model set */
1606
1607/**********************************************************************/
1608/* * *                      MODEL PARAMETERS                      * * */
1609/**********************************************************************/
1610
1611struct PARAMETER
1612{     /* model parameter */
1613      char *name;
1614      /* symbolic name; cannot be NULL */
1615      char *alias;
1616      /* alias; NULL means alias is not specified */
1617      int dim; /* aka arity */
1618      /* dimension (number of subscripts); dim = 0 means 0-dimensional
1619         (unsubscripted) parameter */
1620      DOMAIN *domain;
1621      /* subscript domain; NULL for 0-dimensional parameter */
1622      int type;
1623      /* parameter type:
1624         A_NUMERIC  - numeric
1625         A_INTEGER  - integer
1626         A_BINARY   - binary
1627         A_SYMBOLIC - symbolic */
1628      CONDITION *cond;
1629      /* list of conditions, which restrict each parameter member to
1630         satisfy to every condition from this list; this list is used
1631         only for numeric parameters and can be empty */
1632      WITHIN *in;
1633      /* list of supersets, which restrict each parameter member to be
1634         in every superset from this list; this list is used only for
1635         symbolic parameters and can be empty */
1636      CODE *assign;
1637      /* pseudo-code for computing assigned value; can be NULL */
1638      CODE *option;
1639      /* pseudo-code for computing default value; can be NULL */
1640      int data;
1641      /* data status flag:
1642         0 - no data are provided in the data section
1643         1 - data are provided, but not checked yet
1644         2 - data are provided and have been checked */
1645      SYMBOL *defval;
1646      /* default value provided in the data section; can be NULL */
1647      ARRAY *array;
1648      /* array of members, which are assigned numbers or symbols */
1649};
1650
1651struct CONDITION
1652{     /* restricting condition list entry */
1653      int rho;
1654      /* flag that specifies the form of the condition:
1655         O_LT - less than
1656         O_LE - less than or equal to
1657         O_EQ - equal to
1658         O_GE - greater than or equal to
1659         O_GT - greater than
1660         O_NE - not equal to */
1661      CODE *code;
1662      /* pseudo-code for computing the reference value */
1663      CONDITION *next;
1664      /* the next entry for the same parameter */
1665};
1666
1667#define check_value_num _glp_mpl_check_value_num
1668void check_value_num
1669(     MPL *mpl,
1670      PARAMETER *par,         /* not changed */
1671      TUPLE *tuple,           /* not changed */
1672      double value
1673);
1674/* check numeric value assigned to parameter member */
1675
1676#define take_member_num _glp_mpl_take_member_num
1677double take_member_num
1678(     MPL *mpl,
1679      PARAMETER *par,         /* not changed */
1680      TUPLE *tuple            /* not changed */
1681);
1682/* obtain numeric value assigned to parameter member */
1683
1684#define eval_member_num _glp_mpl_eval_member_num
1685double eval_member_num
1686(     MPL *mpl,
1687      PARAMETER *par,         /* not changed */
1688      TUPLE *tuple            /* not changed */
1689);
1690/* evaluate numeric value assigned to parameter member */
1691
1692#define check_value_sym _glp_mpl_check_value_sym
1693void check_value_sym
1694(     MPL *mpl,
1695      PARAMETER *par,         /* not changed */
1696      TUPLE *tuple,           /* not changed */
1697      SYMBOL *value           /* not changed */
1698);
1699/* check symbolic value assigned to parameter member */
1700
1701#define take_member_sym _glp_mpl_take_member_sym
1702SYMBOL *take_member_sym       /* returns value, not reference */
1703(     MPL *mpl,
1704      PARAMETER *par,         /* not changed */
1705      TUPLE *tuple            /* not changed */
1706);
1707/* obtain symbolic value assigned to parameter member */
1708
1709#define eval_member_sym _glp_mpl_eval_member_sym
1710SYMBOL *eval_member_sym       /* returns value, not reference */
1711(     MPL *mpl,
1712      PARAMETER *par,         /* not changed */
1713      TUPLE *tuple            /* not changed */
1714);
1715/* evaluate symbolic value assigned to parameter member */
1716
1717#define eval_whole_par _glp_mpl_eval_whole_par
1718void eval_whole_par(MPL *mpl, PARAMETER *par);
1719/* evaluate model parameter over entire domain */
1720
1721#define clean_parameter _glp_mpl_clean_parameter
1722void clean_parameter(MPL *mpl, PARAMETER *par);
1723/* clean model parameter */
1724
1725/**********************************************************************/
1726/* * *                      MODEL VARIABLES                       * * */
1727/**********************************************************************/
1728
1729struct VARIABLE
1730{     /* model variable */
1731      char *name;
1732      /* symbolic name; cannot be NULL */
1733      char *alias;
1734      /* alias; NULL means alias is not specified */
1735      int dim; /* aka arity */
1736      /* dimension (number of subscripts); dim = 0 means 0-dimensional
1737         (unsubscripted) variable */
1738      DOMAIN *domain;
1739      /* subscript domain; NULL for 0-dimensional variable */
1740      int type;
1741      /* variable type:
1742         A_NUMERIC - continuous
1743         A_INTEGER - integer
1744         A_BINARY  - binary */
1745      CODE *lbnd;
1746      /* pseudo-code for computing lower bound; NULL means lower bound
1747         is not specified */
1748      CODE *ubnd;
1749      /* pseudo-code for computing upper bound; NULL means upper bound
1750         is not specified */
1751      /* if both the pointers lbnd and ubnd refer to the same code, the
1752         variable is fixed at the corresponding value */
1753      ARRAY *array;
1754      /* array of members, which are assigned elemental variables */
1755};
1756
1757#define take_member_var _glp_mpl_take_member_var
1758ELEMVAR *take_member_var      /* returns reference */
1759(     MPL *mpl,
1760      VARIABLE *var,          /* not changed */
1761      TUPLE *tuple            /* not changed */
1762);
1763/* obtain reference to elemental variable */
1764
1765#define eval_member_var _glp_mpl_eval_member_var
1766ELEMVAR *eval_member_var      /* returns reference */
1767(     MPL *mpl,
1768      VARIABLE *var,          /* not changed */
1769      TUPLE *tuple            /* not changed */
1770);
1771/* evaluate reference to elemental variable */
1772
1773#define eval_whole_var _glp_mpl_eval_whole_var
1774void eval_whole_var(MPL *mpl, VARIABLE *var);
1775/* evaluate model variable over entire domain */
1776
1777#define clean_variable _glp_mpl_clean_variable
1778void clean_variable(MPL *mpl, VARIABLE *var);
1779/* clean model variable */
1780
1781/**********************************************************************/
1782/* * *              MODEL CONSTRAINTS AND OBJECTIVES              * * */
1783/**********************************************************************/
1784
1785struct CONSTRAINT
1786{     /* model constraint or objective */
1787      char *name;
1788      /* symbolic name; cannot be NULL */
1789      char *alias;
1790      /* alias; NULL means alias is not specified */
1791      int dim; /* aka arity */
1792      /* dimension (number of subscripts); dim = 0 means 0-dimensional
1793         (unsubscripted) constraint */
1794      DOMAIN *domain;
1795      /* subscript domain; NULL for 0-dimensional constraint */
1796      int type;
1797      /* constraint type:
1798         A_CONSTRAINT - constraint
1799         A_MINIMIZE   - objective (minimization)
1800         A_MAXIMIZE   - objective (maximization) */
1801      CODE *code;
1802      /* pseudo-code for computing main linear form; cannot be NULL */
1803      CODE *lbnd;
1804      /* pseudo-code for computing lower bound; NULL means lower bound
1805         is not specified */
1806      CODE *ubnd;
1807      /* pseudo-code for computing upper bound; NULL means upper bound
1808         is not specified */
1809      /* if both the pointers lbnd and ubnd refer to the same code, the
1810         constraint has the form of equation */
1811      ARRAY *array;
1812      /* array of members, which are assigned elemental constraints */
1813};
1814
1815#define take_member_con _glp_mpl_take_member_con
1816ELEMCON *take_member_con      /* returns reference */
1817(     MPL *mpl,
1818      CONSTRAINT *con,        /* not changed */
1819      TUPLE *tuple            /* not changed */
1820);
1821/* obtain reference to elemental constraint */
1822
1823#define eval_member_con _glp_mpl_eval_member_con
1824ELEMCON *eval_member_con      /* returns reference */
1825(     MPL *mpl,
1826      CONSTRAINT *con,        /* not changed */
1827      TUPLE *tuple            /* not changed */
1828);
1829/* evaluate reference to elemental constraint */
1830
1831#define eval_whole_con _glp_mpl_eval_whole_con
1832void eval_whole_con(MPL *mpl, CONSTRAINT *con);
1833/* evaluate model constraint over entire domain */
1834
1835#define clean_constraint _glp_mpl_clean_constraint
1836void clean_constraint(MPL *mpl, CONSTRAINT *con);
1837/* clean model constraint */
1838
1839/**********************************************************************/
1840/* * *                        DATA TABLES                         * * */
1841/**********************************************************************/
1842
1843struct TABLE
1844{     /* data table */
1845      char *name;
1846      /* symbolic name; cannot be NULL */
1847      char *alias;
1848      /* alias; NULL means alias is not specified */
1849      int type;
1850      /* table type:
1851         A_INPUT  - input table
1852         A_OUTPUT - output table */
1853      TABARG *arg;
1854      /* argument list; cannot be empty */
1855      union
1856      {  struct
1857         {  SET *set;
1858            /* input set; NULL means the set is not specified */
1859            TABFLD *fld;
1860            /* field list; cannot be empty */
1861            TABIN *list;
1862            /* input list; can be empty */
1863         } in;
1864         struct
1865         {  DOMAIN *domain;
1866            /* subscript domain; cannot be NULL */
1867            TABOUT *list;
1868            /* output list; cannot be empty */
1869         } out;
1870      } u;
1871};
1872
1873struct TABARG
1874{     /* table argument list entry */
1875      CODE *code;
1876      /* pseudo-code for computing the argument */
1877      TABARG *next;
1878      /* next entry for the same table */
1879};
1880
1881struct TABFLD
1882{     /* table field list entry */
1883      char *name;
1884      /* field name; cannot be NULL */
1885      TABFLD *next;
1886      /* next entry for the same table */
1887};
1888
1889struct TABIN
1890{     /* table input list entry */
1891      PARAMETER *par;
1892      /* parameter to be read; cannot be NULL */
1893      char *name;
1894      /* column name; cannot be NULL */
1895      TABIN *next;
1896      /* next entry for the same table */
1897};
1898
1899struct TABOUT
1900{     /* table output list entry */
1901      CODE *code;
1902      /* pseudo-code for computing the value to be written */
1903      char *name;
1904      /* column name; cannot be NULL */
1905      TABOUT *next;
1906      /* next entry for the same table */
1907};
1908
1909struct TABDCA
1910{     /* table driver communication area */
1911      int id;
1912      /* driver identifier (set by mpl_tab_drv_open) */
1913      void *link;
1914      /* driver link pointer (set by mpl_tab_drv_open) */
1915      int na;
1916      /* number of arguments */
1917      char **arg; /* char *arg[1+ns]; */
1918      /* arg[k], 1 <= k <= ns, is pointer to k-th argument */
1919      int nf;
1920      /* number of fields */
1921      char **name; /* char *name[1+nc]; */
1922      /* name[k], 1 <= k <= nc, is name of k-th field */
1923      int *type; /* int type[1+nc]; */
1924      /* type[k], 1 <= k <= nc, is type of k-th field:
1925         '?' - value not assigned
1926         'N' - number
1927         'S' - character string */
1928      double *num; /* double num[1+nc]; */
1929      /* num[k], 1 <= k <= nc, is numeric value of k-th field */
1930      char **str;
1931      /* str[k], 1 <= k <= nc, is string value of k-th field */
1932};
1933
1934#define mpl_tab_num_args _glp_mpl_tab_num_args
1935int mpl_tab_num_args(TABDCA *dca);
1936
1937#define mpl_tab_get_arg _glp_mpl_tab_get_arg
1938const char *mpl_tab_get_arg(TABDCA *dca, int k);
1939
1940#define mpl_tab_num_flds _glp_mpl_tab_num_flds
1941int mpl_tab_num_flds(TABDCA *dca);
1942
1943#define mpl_tab_get_name _glp_mpl_tab_get_name
1944const char *mpl_tab_get_name(TABDCA *dca, int k);
1945
1946#define mpl_tab_get_type _glp_mpl_tab_get_type
1947int mpl_tab_get_type(TABDCA *dca, int k);
1948
1949#define mpl_tab_get_num _glp_mpl_tab_get_num
1950double mpl_tab_get_num(TABDCA *dca, int k);
1951
1952#define mpl_tab_get_str _glp_mpl_tab_get_str
1953const char *mpl_tab_get_str(TABDCA *dca, int k);
1954
1955#define mpl_tab_set_num _glp_mpl_tab_set_num
1956void mpl_tab_set_num(TABDCA *dca, int k, double num);
1957
1958#define mpl_tab_set_str _glp_mpl_tab_set_str
1959void mpl_tab_set_str(TABDCA *dca, int k, const char *str);
1960
1961#define mpl_tab_drv_open _glp_mpl_tab_drv_open
1962void mpl_tab_drv_open(MPL *mpl, int mode);
1963
1964#define mpl_tab_drv_read _glp_mpl_tab_drv_read
1965int mpl_tab_drv_read(MPL *mpl);
1966
1967#define mpl_tab_drv_write _glp_mpl_tab_drv_write
1968void mpl_tab_drv_write(MPL *mpl);
1969
1970#define mpl_tab_drv_close _glp_mpl_tab_drv_close
1971void mpl_tab_drv_close(MPL *mpl);
1972
1973/**********************************************************************/
1974/* * *                        PSEUDO-CODE                         * * */
1975/**********************************************************************/
1976
1977union OPERANDS
1978{     /* operands that participate in pseudo-code operation (choice of
1979         particular operands depends on the operation code) */
1980      /*--------------------------------------------------------------*/
1981      double num;             /* O_NUMBER */
1982      /* floaing-point number to be taken */
1983      /*--------------------------------------------------------------*/
1984      char *str;              /* O_STRING */
1985      /* character string to be taken */
1986      /*--------------------------------------------------------------*/
1987      struct                  /* O_INDEX */
1988      {  DOMAIN_SLOT *slot;
1989         /* domain slot, which contains dummy index to be taken */
1990         CODE *next;
1991         /* the next pseudo-code with op = O_INDEX, which refers to the
1992            same slot as this one; pointer to the beginning of this list
1993            is stored in the corresponding domain slot */
1994      } index;
1995      /*--------------------------------------------------------------*/
1996      struct                  /* O_MEMNUM, O_MEMSYM */
1997      {  PARAMETER *par;
1998         /* model parameter, which contains member to be taken */
1999         ARG_LIST *list;
2000         /* list of subscripts; NULL for 0-dimensional parameter */
2001      } par;
2002      /*--------------------------------------------------------------*/
2003      struct                  /* O_MEMSET */
2004      {  SET *set;
2005         /* model set, which contains member to be taken */
2006         ARG_LIST *list;
2007         /* list of subscripts; NULL for 0-dimensional set */
2008      } set;
2009      /*--------------------------------------------------------------*/
2010      struct                  /* O_MEMVAR */
2011      {  VARIABLE *var;
2012         /* model variable, which contains member to be taken */
2013         ARG_LIST *list;
2014         /* list of subscripts; NULL for 0-dimensional variable */
2015#if 1 /* 15/V-2010 */
2016         int suff;
2017         /* suffix specified: */
2018#define DOT_NONE        0x00  /* none     (means variable itself) */
2019#define DOT_LB          0x01  /* .lb      (lower bound) */
2020#define DOT_UB          0x02  /* .ub      (upper bound) */
2021#define DOT_STATUS      0x03  /* .status  (status) */
2022#define DOT_VAL         0x04  /* .val     (primal value) */
2023#define DOT_DUAL        0x05  /* .dual    (dual value) */
2024#endif
2025      } var;
2026#if 1 /* 15/V-2010 */
2027      /*--------------------------------------------------------------*/
2028      struct                  /* O_MEMCON */
2029      {  CONSTRAINT *con;
2030         /* model constraint, which contains member to be taken */
2031         ARG_LIST *list;
2032         /* list of subscripys; NULL for 0-dimensional constraint */
2033         int suff;
2034         /* suffix specified (see O_MEMVAR above) */
2035      } con;
2036#endif
2037      /*--------------------------------------------------------------*/
2038      ARG_LIST *list;         /* O_TUPLE, O_MAKE, n-ary operations */
2039      /* list of operands */
2040      /*--------------------------------------------------------------*/
2041      DOMAIN_BLOCK *slice;    /* O_SLICE */
2042      /* domain block, which specifies slice (i.e. n-tuple that contains
2043         free dummy indices); this operation is never evaluated */
2044      /*--------------------------------------------------------------*/
2045      struct                  /* unary, binary, ternary operations */
2046      {  CODE *x;
2047         /* pseudo-code for computing first operand */
2048         CODE *y;
2049         /* pseudo-code for computing second operand */
2050         CODE *z;
2051         /* pseudo-code for computing third operand */
2052      } arg;
2053      /*--------------------------------------------------------------*/
2054      struct                  /* iterated operations */
2055      {  DOMAIN *domain;
2056         /* domain, over which the operation is performed */
2057         CODE *x;
2058         /* pseudo-code for computing "integrand" */
2059      } loop;
2060      /*--------------------------------------------------------------*/
2061};
2062
2063struct ARG_LIST
2064{     /* operands list entry */
2065      CODE *x;
2066      /* pseudo-code for computing operand */
2067      ARG_LIST *next;
2068      /* the next operand of the same operation */
2069};
2070
2071struct CODE
2072{     /* pseudo-code (internal form of expressions) */
2073      int op;
2074      /* operation code: */
2075#define O_NUMBER        301   /* take floating-point number */
2076#define O_STRING        302   /* take character string */
2077#define O_INDEX         303   /* take dummy index */
2078#define O_MEMNUM        304   /* take member of numeric parameter */
2079#define O_MEMSYM        305   /* take member of symbolic parameter */
2080#define O_MEMSET        306   /* take member of set */
2081#define O_MEMVAR        307   /* take member of variable */
2082#define O_MEMCON        308   /* take member of constraint */
2083#define O_TUPLE         309   /* make n-tuple */
2084#define O_MAKE          310   /* make elemental set of n-tuples */
2085#define O_SLICE         311   /* define domain block (dummy op) */
2086                              /* 0-ary operations --------------------*/
2087#define O_IRAND224      312   /* pseudo-random in [0, 2^24-1] */
2088#define O_UNIFORM01     313   /* pseudo-random in [0, 1) */
2089#define O_NORMAL01      314   /* gaussian random, mu = 0, sigma = 1 */
2090#define O_GMTIME        315   /* current calendar time (UTC) */
2091                              /* unary operations --------------------*/
2092#define O_CVTNUM        316   /* conversion to numeric */
2093#define O_CVTSYM        317   /* conversion to symbolic */
2094#define O_CVTLOG        318   /* conversion to logical */
2095#define O_CVTTUP        319   /* conversion to 1-tuple */
2096#define O_CVTLFM        320   /* conversion to linear form */
2097#define O_PLUS          321   /* unary plus */
2098#define O_MINUS         322   /* unary minus */
2099#define O_NOT           323   /* negation (logical "not") */
2100#define O_ABS           324   /* absolute value */
2101#define O_CEIL          325   /* round upward ("ceiling of x") */
2102#define O_FLOOR         326   /* round downward ("floor of x") */
2103#define O_EXP           327   /* base-e exponential */
2104#define O_LOG           328   /* natural logarithm */
2105#define O_LOG10         329   /* common (decimal) logarithm */
2106#define O_SQRT          330   /* square root */
2107#define O_SIN           331   /* trigonometric sine */
2108#define O_COS           332   /* trigonometric cosine */
2109#define O_ATAN          333   /* trigonometric arctangent */
2110#define O_ROUND         334   /* round to nearest integer */
2111#define O_TRUNC         335   /* truncate to nearest integer */
2112#define O_CARD          336   /* cardinality of set */
2113#define O_LENGTH        337   /* length of symbolic value */
2114                              /* binary operations -------------------*/
2115#define O_ADD           338   /* addition */
2116#define O_SUB           339   /* subtraction */
2117#define O_LESS          340   /* non-negative subtraction */
2118#define O_MUL           341   /* multiplication */
2119#define O_DIV           342   /* division */
2120#define O_IDIV          343   /* quotient of exact division */
2121#define O_MOD           344   /* remainder of exact division */
2122#define O_POWER         345   /* exponentiation (raise to power) */
2123#define O_ATAN2         346   /* trigonometric arctangent */
2124#define O_ROUND2        347   /* round to n fractional digits */
2125#define O_TRUNC2        348   /* truncate to n fractional digits */
2126#define O_UNIFORM       349   /* pseudo-random in [a, b) */
2127#define O_NORMAL        350   /* gaussian random, given mu and sigma */
2128#define O_CONCAT        351   /* concatenation */
2129#define O_LT            352   /* comparison on 'less than' */
2130#define O_LE            353   /* comparison on 'not greater than' */
2131#define O_EQ            354   /* comparison on 'equal to' */
2132#define O_GE            355   /* comparison on 'not less than' */
2133#define O_GT            356   /* comparison on 'greater than' */
2134#define O_NE            357   /* comparison on 'not equal to' */
2135#define O_AND           358   /* conjunction (logical "and") */
2136#define O_OR            359   /* disjunction (logical "or") */
2137#define O_UNION         360   /* union */
2138#define O_DIFF          361   /* difference */
2139#define O_SYMDIFF       362   /* symmetric difference */
2140#define O_INTER         363   /* intersection */
2141#define O_CROSS         364   /* cross (Cartesian) product */
2142#define O_IN            365   /* test on 'x in Y' */
2143#define O_NOTIN         366   /* test on 'x not in Y' */
2144#define O_WITHIN        367   /* test on 'X within Y' */
2145#define O_NOTWITHIN     368   /* test on 'X not within Y' */
2146#define O_SUBSTR        369   /* substring */
2147#define O_STR2TIME      370   /* convert string to time */
2148#define O_TIME2STR      371   /* convert time to string */
2149                              /* ternary operations ------------------*/
2150#define O_DOTS          372   /* build "arithmetic" set */
2151#define O_FORK          373   /* if-then-else */
2152#define O_SUBSTR3       374   /* substring */
2153                              /* n-ary operations --------------------*/
2154#define O_MIN           375   /* minimal value (n-ary) */
2155#define O_MAX           376   /* maximal value (n-ary) */
2156                              /* iterated operations -----------------*/
2157#define O_SUM           377   /* summation */
2158#define O_PROD          378   /* multiplication */
2159#define O_MINIMUM       379   /* minimum */
2160#define O_MAXIMUM       380   /* maximum */
2161#define O_FORALL        381   /* conjunction (A-quantification) */
2162#define O_EXISTS        382   /* disjunction (E-quantification) */
2163#define O_SETOF         383   /* compute elemental set */
2164#define O_BUILD         384   /* build elemental set */
2165      OPERANDS arg;
2166      /* operands that participate in the operation */
2167      int type;
2168      /* type of the resultant value:
2169         A_NUMERIC  - numeric
2170         A_SYMBOLIC - symbolic
2171         A_LOGICAL  - logical
2172         A_TUPLE    - n-tuple
2173         A_ELEMSET  - elemental set
2174         A_FORMULA  - linear form */
2175      int dim;
2176      /* dimension of the resultant value; for A_TUPLE and A_ELEMSET it
2177         is the dimension of the corresponding n-tuple(s) and cannot be
2178         zero; for other resultant types it is always zero */
2179      CODE *up;
2180      /* parent pseudo-code, which refers to this pseudo-code as to its
2181         operand; NULL means this pseudo-code has no parent and defines
2182         an expression, which is not contained in another expression */
2183      int vflag;
2184      /* volatile flag; being set this flag means that this operation
2185         has a side effect; for primary expressions this flag is set
2186         directly by corresponding parsing routines (for example, if
2187         primary expression is a reference to a function that generates
2188         pseudo-random numbers); in other cases this flag is inherited
2189         from operands */
2190      int valid;
2191      /* if this flag is set, the resultant value, which is a temporary
2192         result of evaluating this operation on particular values of
2193         operands, is valid; if this flag is clear, the resultant value
2194         doesn't exist and therefore not valid; having been evaluated
2195         the resultant value is stored here and not destroyed until the
2196         dummy indices, which this value depends on, have been changed
2197         (and if it doesn't depend on dummy indices at all, it is never
2198         destroyed); thus, if the resultant value is valid, evaluating
2199         routine can immediately take its copy not computing the result
2200         from scratch; this mechanism is similar to moving invariants
2201         out of loops and allows improving efficiency at the expense of
2202         some extra memory needed to keep temporary results */
2203      /* however, if the volatile flag (see above) is set, even if the
2204         resultant value is valid, evaluating routine computes it as if
2205         it were not valid, i.e. caching is not used in this case */
2206      VALUE value;
2207      /* resultant value in generic format */
2208};
2209
2210#define eval_numeric _glp_mpl_eval_numeric
2211double eval_numeric(MPL *mpl, CODE *code);
2212/* evaluate pseudo-code to determine numeric value */
2213
2214#define eval_symbolic _glp_mpl_eval_symbolic
2215SYMBOL *eval_symbolic(MPL *mpl, CODE *code);
2216/* evaluate pseudo-code to determine symbolic value */
2217
2218#define eval_logical _glp_mpl_eval_logical
2219int eval_logical(MPL *mpl, CODE *code);
2220/* evaluate pseudo-code to determine logical value */
2221
2222#define eval_tuple _glp_mpl_eval_tuple
2223TUPLE *eval_tuple(MPL *mpl, CODE *code);
2224/* evaluate pseudo-code to construct n-tuple */
2225
2226#define eval_elemset _glp_mpl_eval_elemset
2227ELEMSET *eval_elemset(MPL *mpl, CODE *code);
2228/* evaluate pseudo-code to construct elemental set */
2229
2230#define is_member _glp_mpl_is_member
2231int is_member(MPL *mpl, CODE *code, TUPLE *tuple);
2232/* check if n-tuple is in set specified by pseudo-code */
2233
2234#define eval_formula _glp_mpl_eval_formula
2235FORMULA *eval_formula(MPL *mpl, CODE *code);
2236/* evaluate pseudo-code to construct linear form */
2237
2238#define clean_code _glp_mpl_clean_code
2239void clean_code(MPL *mpl, CODE *code);
2240/* clean pseudo-code */
2241
2242/**********************************************************************/
2243/* * *                      MODEL STATEMENTS                      * * */
2244/**********************************************************************/
2245
2246struct CHECK
2247{     /* check statement */
2248      DOMAIN *domain;
2249      /* subscript domain; NULL means domain is not used */
2250      CODE *code;
2251      /* code for computing the predicate to be checked */
2252};
2253
2254struct DISPLAY
2255{     /* display statement */
2256      DOMAIN *domain;
2257      /* subscript domain; NULL means domain is not used */
2258      DISPLAY1 *list;
2259      /* display list; cannot be empty */
2260};
2261
2262struct DISPLAY1
2263{     /* display list entry */
2264      int type;
2265      /* item type:
2266         A_INDEX      - dummy index
2267         A_SET        - model set
2268         A_PARAMETER  - model parameter
2269         A_VARIABLE   - model variable
2270         A_CONSTRAINT - model constraint/objective
2271         A_EXPRESSION - expression */
2272      union
2273      {  DOMAIN_SLOT *slot;
2274         SET *set;
2275         PARAMETER *par;
2276         VARIABLE *var;
2277         CONSTRAINT *con;
2278         CODE *code;
2279      } u;
2280      /* item to be displayed */
2281#if 0 /* 15/V-2010 */
2282      ARG_LIST *list;
2283      /* optional subscript list (for constraint/objective only) */
2284#endif
2285      DISPLAY1 *next;
2286      /* the next entry for the same statement */
2287};
2288
2289struct PRINTF
2290{     /* printf statement */
2291      DOMAIN *domain;
2292      /* subscript domain; NULL means domain is not used */
2293      CODE *fmt;
2294      /* pseudo-code for computing format string */
2295      PRINTF1 *list;
2296      /* printf list; can be empty */
2297      CODE *fname;
2298      /* pseudo-code for computing filename to redirect the output;
2299         NULL means the output goes to stdout */
2300      int app;
2301      /* if this flag is set, the output is appended */
2302};
2303
2304struct PRINTF1
2305{     /* printf list entry */
2306      CODE *code;
2307      /* pseudo-code for computing value to be printed */
2308      PRINTF1 *next;
2309      /* the next entry for the same statement */
2310};
2311
2312struct FOR
2313{     /* for statement */
2314      DOMAIN *domain;
2315      /* subscript domain; cannot be NULL */
2316      STATEMENT *list;
2317      /* linked list of model statements within this for statement in
2318         the original order */
2319};
2320
2321struct STATEMENT
2322{     /* model statement */
2323      int line;
2324      /* number of source text line, where statement begins */
2325      int type;
2326      /* statement type:
2327         A_SET        - set statement
2328         A_PARAMETER  - parameter statement
2329         A_VARIABLE   - variable statement
2330         A_CONSTRAINT - constraint/objective statement
2331         A_TABLE      - table statement
2332         A_SOLVE      - solve statement
2333         A_CHECK      - check statement
2334         A_DISPLAY    - display statement
2335         A_PRINTF     - printf statement
2336         A_FOR        - for statement */
2337      union
2338      {  SET *set;
2339         PARAMETER *par;
2340         VARIABLE *var;
2341         CONSTRAINT *con;
2342         TABLE *tab;
2343         void *slv; /* currently not used (set to NULL) */
2344         CHECK *chk;
2345         DISPLAY *dpy;
2346         PRINTF *prt;
2347         FOR *fur;
2348      } u;
2349      /* specific part of statement */
2350      STATEMENT *next;
2351      /* the next statement; in this list statements follow in the same
2352         order as they appear in the model section */
2353};
2354
2355#define execute_table _glp_mpl_execute_table
2356void execute_table(MPL *mpl, TABLE *tab);
2357/* execute table statement */
2358
2359#define free_dca _glp_mpl_free_dca
2360void free_dca(MPL *mpl);
2361/* free table driver communucation area */
2362
2363#define clean_table _glp_mpl_clean_table
2364void clean_table(MPL *mpl, TABLE *tab);
2365/* clean table statement */
2366
2367#define execute_check _glp_mpl_execute_check
2368void execute_check(MPL *mpl, CHECK *chk);
2369/* execute check statement */
2370
2371#define clean_check _glp_mpl_clean_check
2372void clean_check(MPL *mpl, CHECK *chk);
2373/* clean check statement */
2374
2375#define execute_display _glp_mpl_execute_display
2376void execute_display(MPL *mpl, DISPLAY *dpy);
2377/* execute display statement */
2378
2379#define clean_display _glp_mpl_clean_display
2380void clean_display(MPL *mpl, DISPLAY *dpy);
2381/* clean display statement */
2382
2383#define execute_printf _glp_mpl_execute_printf
2384void execute_printf(MPL *mpl, PRINTF *prt);
2385/* execute printf statement */
2386
2387#define clean_printf _glp_mpl_clean_printf
2388void clean_printf(MPL *mpl, PRINTF *prt);
2389/* clean printf statement */
2390
2391#define execute_for _glp_mpl_execute_for
2392void execute_for(MPL *mpl, FOR *fur);
2393/* execute for statement */
2394
2395#define clean_for _glp_mpl_clean_for
2396void clean_for(MPL *mpl, FOR *fur);
2397/* clean for statement */
2398
2399#define execute_statement _glp_mpl_execute_statement
2400void execute_statement(MPL *mpl, STATEMENT *stmt);
2401/* execute specified model statement */
2402
2403#define clean_statement _glp_mpl_clean_statement
2404void clean_statement(MPL *mpl, STATEMENT *stmt);
2405/* clean specified model statement */
2406
2407/**********************************************************************/
2408/* * *              GENERATING AND POSTSOLVING MODEL              * * */
2409/**********************************************************************/
2410
2411#define alloc_content _glp_mpl_alloc_content
2412void alloc_content(MPL *mpl);
2413/* allocate content arrays for all model objects */
2414
2415#define generate_model _glp_mpl_generate_model
2416void generate_model(MPL *mpl);
2417/* generate model */
2418
2419#define build_problem _glp_mpl_build_problem
2420void build_problem(MPL *mpl);
2421/* build problem instance */
2422
2423#define postsolve_model _glp_mpl_postsolve_model
2424void postsolve_model(MPL *mpl);
2425/* postsolve model */
2426
2427#define clean_model _glp_mpl_clean_model
2428void clean_model(MPL *mpl);
2429/* clean model content */
2430
2431/**********************************************************************/
2432/* * *                        INPUT/OUTPUT                        * * */
2433/**********************************************************************/
2434
2435#define open_input _glp_mpl_open_input
2436void open_input(MPL *mpl, char *file);
2437/* open input text file */
2438
2439#define read_char _glp_mpl_read_char
2440int read_char(MPL *mpl);
2441/* read next character from input text file */
2442
2443#define close_input _glp_mpl_close_input
2444void close_input(MPL *mpl);
2445/* close input text file */
2446
2447#define open_output _glp_mpl_open_output
2448void open_output(MPL *mpl, char *file);
2449/* open output text file */
2450
2451#define write_char _glp_mpl_write_char
2452void write_char(MPL *mpl, int c);
2453/* write next character to output text file */
2454
2455#define write_text _glp_mpl_write_text
2456void write_text(MPL *mpl, char *fmt, ...);
2457/* format and write text to output text file */
2458
2459#define flush_output _glp_mpl_flush_output
2460void flush_output(MPL *mpl);
2461/* finalize writing data to output text file */
2462
2463/**********************************************************************/
2464/* * *                      SOLVER INTERFACE                      * * */
2465/**********************************************************************/
2466
2467#define MPL_FR          401   /* free (unbounded) */
2468#define MPL_LO          402   /* lower bound */
2469#define MPL_UP          403   /* upper bound */
2470#define MPL_DB          404   /* both lower and upper bounds */
2471#define MPL_FX          405   /* fixed */
2472
2473#define MPL_ST          411   /* constraint */
2474#define MPL_MIN         412   /* objective (minimization) */
2475#define MPL_MAX         413   /* objective (maximization) */
2476
2477#define MPL_NUM         421   /* continuous */
2478#define MPL_INT         422   /* integer */
2479#define MPL_BIN         423   /* binary */
2480
2481#define error _glp_mpl_error
2482void error(MPL *mpl, char *fmt, ...);
2483/* print error message and terminate model processing */
2484
2485#define warning _glp_mpl_warning
2486void warning(MPL *mpl, char *fmt, ...);
2487/* print warning message and continue model processing */
2488
2489#define mpl_initialize _glp_mpl_initialize
2490MPL *mpl_initialize(void);
2491/* create and initialize translator database */
2492
2493#define mpl_read_model _glp_mpl_read_model
2494int mpl_read_model(MPL *mpl, char *file, int skip_data);
2495/* read model section and optional data section */
2496
2497#define mpl_read_data _glp_mpl_read_data
2498int mpl_read_data(MPL *mpl, char *file);
2499/* read data section */
2500
2501#define mpl_generate _glp_mpl_generate
2502int mpl_generate(MPL *mpl, char *file);
2503/* generate model */
2504
2505#define mpl_get_prob_name _glp_mpl_get_prob_name
2506char *mpl_get_prob_name(MPL *mpl);
2507/* obtain problem (model) name */
2508
2509#define mpl_get_num_rows _glp_mpl_get_num_rows
2510int mpl_get_num_rows(MPL *mpl);
2511/* determine number of rows */
2512
2513#define mpl_get_num_cols _glp_mpl_get_num_cols
2514int mpl_get_num_cols(MPL *mpl);
2515/* determine number of columns */
2516
2517#define mpl_get_row_name _glp_mpl_get_row_name
2518char *mpl_get_row_name(MPL *mpl, int i);
2519/* obtain row name */
2520
2521#define mpl_get_row_kind _glp_mpl_get_row_kind
2522int mpl_get_row_kind(MPL *mpl, int i);
2523/* determine row kind */
2524
2525#define mpl_get_row_bnds _glp_mpl_get_row_bnds
2526int mpl_get_row_bnds(MPL *mpl, int i, double *lb, double *ub);
2527/* obtain row bounds */
2528
2529#define mpl_get_mat_row _glp_mpl_get_mat_row
2530int mpl_get_mat_row(MPL *mpl, int i, int ndx[], double val[]);
2531/* obtain row of the constraint matrix */
2532
2533#define mpl_get_row_c0 _glp_mpl_get_row_c0
2534double mpl_get_row_c0(MPL *mpl, int i);
2535/* obtain constant term of free row */
2536
2537#define mpl_get_col_name _glp_mpl_get_col_name
2538char *mpl_get_col_name(MPL *mpl, int j);
2539/* obtain column name */
2540
2541#define mpl_get_col_kind _glp_mpl_get_col_kind
2542int mpl_get_col_kind(MPL *mpl, int j);
2543/* determine column kind */
2544
2545#define mpl_get_col_bnds _glp_mpl_get_col_bnds
2546int mpl_get_col_bnds(MPL *mpl, int j, double *lb, double *ub);
2547/* obtain column bounds */
2548
2549#define mpl_has_solve_stmt _glp_mpl_has_solve_stmt
2550int mpl_has_solve_stmt(MPL *mpl);
2551/* check if model has solve statement */
2552
2553#if 1 /* 15/V-2010 */
2554#define mpl_put_row_soln _glp_mpl_put_row_soln
2555void mpl_put_row_soln(MPL *mpl, int i, int stat, double prim,
2556      double dual);
2557/* store row (constraint/objective) solution components */
2558#endif
2559
2560#if 1 /* 15/V-2010 */
2561#define mpl_put_col_soln _glp_mpl_put_col_soln
2562void mpl_put_col_soln(MPL *mpl, int j, int stat, double prim,
2563      double dual);
2564/* store column (variable) solution components */
2565#endif
2566
2567#if 0 /* 15/V-2010 */
2568#define mpl_put_col_value _glp_mpl_put_col_value
2569void mpl_put_col_value(MPL *mpl, int j, double val);
2570/* store column value */
2571#endif
2572
2573#define mpl_postsolve _glp_mpl_postsolve
2574int mpl_postsolve(MPL *mpl);
2575/* postsolve model */
2576
2577#define mpl_terminate _glp_mpl_terminate
2578void mpl_terminate(MPL *mpl);
2579/* free all resources used by translator */
2580
2581#endif
2582
2583/* eof */
Note: See TracBrowser for help on using the repository browser.