Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

glpmpl.h

subpack-glpk

Last change on this file was 9:33de93886c88, checked in by Alpar Juttner <alpar@…>, 13 years ago
Import GLPK 4.47
File size: 87.6 KB

Rev	Line
[9]	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, 2011 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
	31	typedef struct MPL MPL;
	32	typedef char STRING;
	33	typedef struct SYMBOL SYMBOL;
	34	typedef struct TUPLE TUPLE;
	35	typedef struct ARRAY ELEMSET;
	36	typedef struct ELEMVAR ELEMVAR;
	37	typedef struct FORMULA FORMULA;
	38	typedef struct ELEMCON ELEMCON;
	39	typedef union VALUE VALUE;
	40	typedef struct ARRAY ARRAY;
	41	typedef 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
	47	typedef struct DOMAIN DOMAIN;
	48	typedef struct DOMAIN_BLOCK DOMAIN_BLOCK;
	49	typedef struct DOMAIN_SLOT DOMAIN_SLOT;
	50	typedef struct SET SET;
	51	typedef struct WITHIN WITHIN;
	52	typedef struct GADGET GADGET;
	53	typedef struct PARAMETER PARAMETER;
	54	typedef struct CONDITION CONDITION;
	55	typedef struct VARIABLE VARIABLE;
	56	typedef struct CONSTRAINT CONSTRAINT;
	57	typedef struct TABLE TABLE;
	58	typedef struct TABARG TABARG;
	59	typedef struct TABFLD TABFLD;
	60	typedef struct TABIN TABIN;
	61	typedef struct TABOUT TABOUT;
	62	typedef struct TABDCA TABDCA;
	63	typedef union OPERANDS OPERANDS;
	64	typedef struct ARG_LIST ARG_LIST;
	65	typedef struct CODE CODE;
	66	typedef struct CHECK CHECK;
	67	typedef struct DISPLAY DISPLAY;
	68	typedef struct DISPLAY1 DISPLAY1;
	69	typedef struct PRINTF PRINTF;
	70	typedef struct PRINTF1 PRINTF1;
	71	typedef struct FOR FOR;
	72	typedef struct STATEMENT STATEMENT;
	73	typedef 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
	118	struct 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
	334	void enter_context(MPL *mpl);
	335	/* enter current token into context queue */
	336
	337	#define print_context _glp_mpl_print_context
	338	void print_context(MPL *mpl);
	339	/* print current content of context queue */
	340
	341	#define get_char _glp_mpl_get_char
	342	void get_char(MPL *mpl);
	343	/* scan next character from input text file */
	344
	345	#define append_char _glp_mpl_append_char
	346	void append_char(MPL *mpl);
	347	/* append character to current token */
	348
	349	#define get_token _glp_mpl_get_token
	350	void get_token(MPL *mpl);
	351	/* scan next token from input text file */
	352
	353	#define unget_token _glp_mpl_unget_token
	354	void unget_token(MPL *mpl);
	355	/* return current token back to input stream */
	356
	357	#define is_keyword _glp_mpl_is_keyword
	358	int 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
	362	int is_reserved(MPL *mpl);
	363	/* check if current token is reserved keyword */
	364
	365	#define make_code _glp_mpl_make_code
	366	CODE 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
	370	CODE 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
	374	CODE 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
	379	CODE 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
	384	CODE numeric_literal(MPL mpl);
	385	/* parse reference to numeric literal */
	386
	387	#define string_literal _glp_mpl_string_literal
	388	CODE string_literal(MPL mpl);
	389	/* parse reference to string literal */
	390
	391	#define create_arg_list _glp_mpl_create_arg_list
	392	ARG_LIST create_arg_list(MPL mpl);
	393	/* create empty operands list */
	394
	395	#define expand_arg_list _glp_mpl_expand_arg_list
	396	ARG_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
	400	int arg_list_len(MPL mpl, ARG_LIST list);
	401	/* determine length of operands list */
	402
	403	#define subscript_list _glp_mpl_subscript_list
	404	ARG_LIST subscript_list(MPL mpl);
	405	/* parse subscript list */
	406
	407	#define object_reference _glp_mpl_object_reference
	408	CODE object_reference(MPL mpl);
	409	/* parse reference to named object */
	410
	411	#define numeric_argument _glp_mpl_numeric_argument
	412	CODE numeric_argument(MPL mpl, char *func);
	413	/* parse argument passed to built-in function */
	414
	415	#define symbolic_argument _glp_mpl_symbolic_argument
	416	CODE symbolic_argument(MPL mpl, char *func);
	417
	418	#define elemset_argument _glp_mpl_elemset_argument
	419	CODE elemset_argument(MPL mpl, char *func);
	420
	421	#define function_reference _glp_mpl_function_reference
	422	CODE function_reference(MPL mpl);
	423	/* parse reference to built-in function */
	424
	425	#define create_domain _glp_mpl_create_domain
	426	DOMAIN create_domain(MPL mpl);
	427	/* create empty domain */
	428
	429	#define create_block _glp_mpl_create_block
	430	DOMAIN_BLOCK create_block(MPL mpl);
	431	/* create empty domain block */
	432
	433	#define append_block _glp_mpl_append_block
	434	void 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
	438	DOMAIN_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
	443	CODE expression_list(MPL mpl);
	444	/* parse expression list */
	445
	446	#define literal_set _glp_mpl_literal_set
	447	CODE literal_set(MPL mpl, CODE *code);
	448	/* parse literal set */
	449
	450	#define indexing_expression _glp_mpl_indexing_expression
	451	DOMAIN indexing_expression(MPL mpl);
	452	/* parse indexing expression */
	453
	454	#define close_scope _glp_mpl_close_scope
	455	void close_scope(MPL mpl, DOMAIN domain);
	456	/* close scope of indexing expression */
	457
	458	#define iterated_expression _glp_mpl_iterated_expression
	459	CODE iterated_expression(MPL mpl);
	460	/* parse iterated expression */
	461
	462	#define domain_arity _glp_mpl_domain_arity
	463	int domain_arity(MPL mpl, DOMAIN domain);
	464	/* determine arity of domain */
	465
	466	#define set_expression _glp_mpl_set_expression
	467	CODE set_expression(MPL mpl);
	468	/* parse set expression */
	469
	470	#define branched_expression _glp_mpl_branched_expression
	471	CODE branched_expression(MPL mpl);
	472	/* parse conditional expression */
	473
	474	#define primary_expression _glp_mpl_primary_expression
	475	CODE primary_expression(MPL mpl);
	476	/* parse primary expression */
	477
	478	#define error_preceding _glp_mpl_error_preceding
	479	void error_preceding(MPL mpl, char opstr);
	480	/* raise error if preceding operand has wrong type */
	481
	482	#define error_following _glp_mpl_error_following
	483	void error_following(MPL mpl, char opstr);
	484	/* raise error if following operand has wrong type */
	485
	486	#define error_dimension _glp_mpl_error_dimension
	487	void 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
	491	CODE expression_0(MPL mpl);
	492	/* parse expression of level 0 */
	493
	494	#define expression_1 _glp_mpl_expression_1
	495	CODE expression_1(MPL mpl);
	496	/* parse expression of level 1 */
	497
	498	#define expression_2 _glp_mpl_expression_2
	499	CODE expression_2(MPL mpl);
	500	/* parse expression of level 2 */
	501
	502	#define expression_3 _glp_mpl_expression_3
	503	CODE expression_3(MPL mpl);
	504	/* parse expression of level 3 */
	505
	506	#define expression_4 _glp_mpl_expression_4
	507	CODE expression_4(MPL mpl);
	508	/* parse expression of level 4 */
	509
	510	#define expression_5 _glp_mpl_expression_5
	511	CODE expression_5(MPL mpl);
	512	/* parse expression of level 5 */
	513
	514	#define expression_6 _glp_mpl_expression_6
	515	CODE expression_6(MPL mpl);
	516	/* parse expression of level 6 */
	517
	518	#define expression_7 _glp_mpl_expression_7
	519	CODE expression_7(MPL mpl);
	520	/* parse expression of level 7 */
	521
	522	#define expression_8 _glp_mpl_expression_8
	523	CODE expression_8(MPL mpl);
	524	/* parse expression of level 8 */
	525
	526	#define expression_9 _glp_mpl_expression_9
	527	CODE expression_9(MPL mpl);
	528	/* parse expression of level 9 */
	529
	530	#define expression_10 _glp_mpl_expression_10
	531	CODE expression_10(MPL mpl);
	532	/* parse expression of level 10 */
	533
	534	#define expression_11 _glp_mpl_expression_11
	535	CODE expression_11(MPL mpl);
	536	/* parse expression of level 11 */
	537
	538	#define expression_12 _glp_mpl_expression_12
	539	CODE expression_12(MPL mpl);
	540	/* parse expression of level 12 */
	541
	542	#define expression_13 _glp_mpl_expression_13
	543	CODE expression_13(MPL mpl);
	544	/* parse expression of level 13 */
	545
	546	#define set_statement _glp_mpl_set_statement
	547	SET set_statement(MPL mpl);
	548	/* parse set statement */
	549
	550	#define parameter_statement _glp_mpl_parameter_statement
	551	PARAMETER parameter_statement(MPL mpl);
	552	/* parse parameter statement */
	553
	554	#define variable_statement _glp_mpl_variable_statement
	555	VARIABLE variable_statement(MPL mpl);
	556	/* parse variable statement */
	557
	558	#define constraint_statement _glp_mpl_constraint_statement
	559	CONSTRAINT constraint_statement(MPL mpl);
	560	/* parse constraint statement */
	561
	562	#define objective_statement _glp_mpl_objective_statement
	563	CONSTRAINT objective_statement(MPL mpl);
	564	/* parse objective statement */
	565
	566	#define table_statement _glp_mpl_table_statement
	567	TABLE table_statement(MPL mpl);
	568	/* parse table statement */
	569
	570	#define solve_statement _glp_mpl_solve_statement
	571	void solve_statement(MPL mpl);
	572	/* parse solve statement */
	573
	574	#define check_statement _glp_mpl_check_statement
	575	CHECK check_statement(MPL mpl);
	576	/* parse check statement */
	577
	578	#define display_statement _glp_mpl_display_statement
	579	DISPLAY display_statement(MPL mpl);
	580	/* parse display statement */
	581
	582	#define printf_statement _glp_mpl_printf_statement
	583	PRINTF printf_statement(MPL mpl);
	584	/* parse printf statement */
	585
	586	#define for_statement _glp_mpl_for_statement
	587	FOR for_statement(MPL mpl);
	588	/* parse for statement */
	589
	590	#define end_statement _glp_mpl_end_statement
	591	void end_statement(MPL *mpl);
	592	/* parse end statement */
	593
	594	#define simple_statement _glp_mpl_simple_statement
	595	STATEMENT simple_statement(MPL mpl, int spec);
	596	/* parse simple statement */
	597
	598	#define model_section _glp_mpl_model_section
	599	void model_section(MPL *mpl);
	600	/* parse model section */
	601
	602	/**********************************************************************/
	603	/* * * PROCESSING DATA SECTION * * */
	604	/**********************************************************************/
	605
	606	#if 2 + 2 == 5
	607	struct 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
	620	SLICE create_slice(MPL mpl);
	621	/* create slice */
	622
	623	#define expand_slice _glp_mpl_expand_slice
	624	SLICE *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
	632	int 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
	639	int 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
	646	SLICE fake_slice(MPL mpl, int dim);
	647	/* create fake slice of all asterisks */
	648
	649	#define delete_slice _glp_mpl_delete_slice
	650	void delete_slice
	651	( MPL *mpl,
	652	SLICE slice / destroyed */
	653	);
	654	/* delete slice */
	655
	656	#define is_number _glp_mpl_is_number
	657	int is_number(MPL *mpl);
	658	/* check if current token is number */
	659
	660	#define is_symbol _glp_mpl_is_symbol
	661	int is_symbol(MPL *mpl);
	662	/* check if current token is symbol */
	663
	664	#define is_literal _glp_mpl_is_literal
	665	int is_literal(MPL mpl, char literal);
	666	/* check if current token is given symbolic literal */
	667
	668	#define read_number _glp_mpl_read_number
	669	double read_number(MPL *mpl);
	670	/* read number */
	671
	672	#define read_symbol _glp_mpl_read_symbol
	673	SYMBOL read_symbol(MPL mpl);
	674	/* read symbol */
	675
	676	#define read_slice _glp_mpl_read_slice
	677	SLICE *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
	685	SET *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
	692	void 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
	701	void 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
	711	void set_data(MPL *mpl);
	712	/* read set data */
	713
	714	#define select_parameter _glp_mpl_select_parameter
	715	PARAMETER *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
	722	void 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
	730	MEMBER *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
	738	void 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
	746	void 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
	755	void 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
	762	void parameter_data(MPL *mpl);
	763	/* read parameter data */
	764
	765	#define data_section _glp_mpl_data_section
	766	void data_section(MPL *mpl);
	767	/* read data section */
	768
	769	/**********************************************************************/
	770	/* * * FLOATING-POINT NUMBERS * * */
	771	/**********************************************************************/
	772
	773	#define fp_add _glp_mpl_fp_add
	774	double fp_add(MPL *mpl, double x, double y);
	775	/* floating-point addition */
	776
	777	#define fp_sub _glp_mpl_fp_sub
	778	double fp_sub(MPL *mpl, double x, double y);
	779	/* floating-point subtraction */
	780
	781	#define fp_less _glp_mpl_fp_less
	782	double fp_less(MPL *mpl, double x, double y);
	783	/* floating-point non-negative subtraction */
	784
	785	#define fp_mul _glp_mpl_fp_mul
	786	double fp_mul(MPL *mpl, double x, double y);
	787	/* floating-point multiplication */
	788
	789	#define fp_div _glp_mpl_fp_div
	790	double fp_div(MPL *mpl, double x, double y);
	791	/* floating-point division */
	792
	793	#define fp_idiv _glp_mpl_fp_idiv
	794	double fp_idiv(MPL *mpl, double x, double y);
	795	/* floating-point quotient of exact division */
	796
	797	#define fp_mod _glp_mpl_fp_mod
	798	double fp_mod(MPL *mpl, double x, double y);
	799	/* floating-point remainder of exact division */
	800
	801	#define fp_power _glp_mpl_fp_power
	802	double fp_power(MPL *mpl, double x, double y);
	803	/* floating-point exponentiation (raise to power) */
	804
	805	#define fp_exp _glp_mpl_fp_exp
	806	double fp_exp(MPL *mpl, double x);
	807	/* floating-point base-e exponential */
	808
	809	#define fp_log _glp_mpl_fp_log
	810	double fp_log(MPL *mpl, double x);
	811	/* floating-point natural logarithm */
	812
	813	#define fp_log10 _glp_mpl_fp_log10
	814	double fp_log10(MPL *mpl, double x);
	815	/* floating-point common (decimal) logarithm */
	816
	817	#define fp_sqrt _glp_mpl_fp_sqrt
	818	double fp_sqrt(MPL *mpl, double x);
	819	/* floating-point square root */
	820
	821	#define fp_sin _glp_mpl_fp_sin
	822	double fp_sin(MPL *mpl, double x);
	823	/* floating-point trigonometric sine */
	824
	825	#define fp_cos _glp_mpl_fp_cos
	826	double fp_cos(MPL *mpl, double x);
	827	/* floating-point trigonometric cosine */
	828
	829	#define fp_atan _glp_mpl_fp_atan
	830	double fp_atan(MPL *mpl, double x);
	831	/* floating-point trigonometric arctangent */
	832
	833	#define fp_atan2 _glp_mpl_fp_atan2
	834	double fp_atan2(MPL *mpl, double y, double x);
	835	/* floating-point trigonometric arctangent */
	836
	837	#define fp_round _glp_mpl_fp_round
	838	double 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
	842	double 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
	850	double fp_irand224(MPL *mpl);
	851	/* pseudo-random integer in the range [0, 2^24) */
	852
	853	#define fp_uniform01 _glp_mpl_fp_uniform01
	854	double fp_uniform01(MPL *mpl);
	855	/* pseudo-random number in the range [0, 1) */
	856
	857	#define fp_uniform _glp_mpl_uniform
	858	double 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
	862	double fp_normal01(MPL *mpl);
	863	/* Gaussian random variate with mu = 0 and sigma = 1 */
	864
	865	#define fp_normal _glp_mpl_fp_normal
	866	double 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
	874	double fn_gmtime(MPL *mpl);
	875	/* obtain the current calendar time (UTC) */
	876
	877	#define fn_str2time _glp_mpl_fn_str2time
	878	double 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
	882	void 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
	890	STRING *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
	897	STRING *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
	904	int 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
	912	char *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
	920	void delete_string
	921	( MPL *mpl,
	922	STRING str / destroyed */
	923	);
	924	/* delete character string */
	925
	926	/**********************************************************************/
	927	/* * * SYMBOLS * * */
	928	/**********************************************************************/
	929
	930	struct 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
	939	SYMBOL create_symbol_num(MPL mpl, double num);
	940	/* create symbol of numeric type */
	941
	942	#define create_symbol_str _glp_mpl_create_symbol_str
	943	SYMBOL *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
	950	SYMBOL *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
	957	int 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
	965	void delete_symbol
	966	( MPL *mpl,
	967	SYMBOL sym / destroyed */
	968	);
	969	/* delete symbol */
	970
	971	#define format_symbol _glp_mpl_format_symbol
	972	char *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
	979	SYMBOL *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
	990	struct 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
	1000	TUPLE create_tuple(MPL mpl);
	1001	/* create n-tuple */
	1002
	1003	#define expand_tuple _glp_mpl_expand_tuple
	1004	TUPLE *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
	1012	int 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
	1019	TUPLE *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
	1026	int 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
	1034	TUPLE *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
	1042	void delete_tuple
	1043	( MPL *mpl,
	1044	TUPLE tuple / destroyed */
	1045	);
	1046	/* delete n-tuple */
	1047
	1048	#define format_tuple _glp_mpl_format_tuple
	1049	char *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
	1061	struct 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
	1071	ELEMSET create_elemset(MPL mpl, int dim);
	1072	/* create elemental set */
	1073
	1074	#define find_tuple _glp_mpl_find_tuple
	1075	MEMBER *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
	1083	MEMBER *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
	1091	MEMBER *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
	1099	ELEMSET *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
	1106	void delete_elemset
	1107	( MPL *mpl,
	1108	ELEMSET set / destroyed */
	1109	);
	1110	/* delete elemental set */
	1111
	1112	#define arelset_size _glp_mpl_arelset_size
	1113	int 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
	1117	double 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
	1121	ELEMSET create_arelset(MPL mpl, double t0, double tf, double dt);
	1122	/* create "arithmetic" elemental set */
	1123
	1124	#define set_union _glp_mpl_set_union
	1125	ELEMSET *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
	1133	ELEMSET *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
	1141	ELEMSET *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
	1149	ELEMSET *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
	1157	ELEMSET *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
	1168	struct 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
	1196	struct 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
	1210	FORMULA constant_term(MPL mpl, double coef);
	1211	/* create constant term */
	1212
	1213	#define single_variable _glp_mpl_single_variable
	1214	FORMULA *single_variable
	1215	( MPL *mpl,
	1216	ELEMVAR var / referenced */
	1217	);
	1218	/* create single variable */
	1219
	1220	#define copy_formula _glp_mpl_copy_formula
	1221	FORMULA *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
	1228	void delete_formula
	1229	( MPL *mpl,
	1230	FORMULA form / destroyed */
	1231	);
	1232	/* delete linear form */
	1233
	1234	#define linear_comb _glp_mpl_linear_comb
	1235	FORMULA *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
	1243	FORMULA *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
	1251	FORMULA *reduce_terms
	1252	( MPL *mpl,
	1253	FORMULA form / destroyed */
	1254	);
	1255	/* reduce identical terms in linear form */
	1256
	1257	/**********************************************************************/
	1258	/* * * ELEMENTAL CONSTRAINTS * * */
	1259	/**********************************************************************/
	1260
	1261	struct 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
	1288	union 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
	1315	void 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
	1326	struct 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
	1360	struct 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
	1373	ARRAY create_array(MPL mpl, int type, int dim);
	1374	/* create array */
	1375
	1376	#define find_member _glp_mpl_find_member
	1377	MEMBER *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
	1385	MEMBER *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
	1393	void delete_array
	1394	( MPL *mpl,
	1395	ARRAY array / destroyed */
	1396	);
	1397	/* delete array */
	1398
	1399	/**********************************************************************/
	1400	/* * * DOMAINS AND DUMMY INDICES * * */
	1401	/**********************************************************************/
	1402
	1403	struct 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
	1417	struct 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
	1439	struct 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
	1461	void 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
	1469	void 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
	1476	int 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
	1485	int 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
	1494	void 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
	1502	void 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
	1510	TUPLE *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
	1517	void clean_domain(MPL mpl, DOMAIN domain);
	1518	/* clean domain */
	1519
	1520	/**********************************************************************/
	1521	/* * * MODEL SETS * * */
	1522	/**********************************************************************/
	1523
	1524	struct 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
	1558	struct 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
	1566	struct 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
	1575	void 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
	1584	ELEMSET 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
	1592	ELEMSET 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
	1600	void eval_whole_set(MPL mpl, SET set);
	1601	/* evaluate model set over entire domain */
	1602
	1603	#define clean_set _glp_mpl_clean_set
	1604	void clean_set(MPL mpl, SET set);
	1605	/* clean model set */
	1606
	1607	/**********************************************************************/
	1608	/* * * MODEL PARAMETERS * * */
	1609	/**********************************************************************/
	1610
	1611	struct 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
	1651	struct 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
	1668	void 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
	1677	double 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
	1685	double 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
	1693	void 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
	1702	SYMBOL 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
	1710	SYMBOL 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
	1718	void eval_whole_par(MPL mpl, PARAMETER par);
	1719	/* evaluate model parameter over entire domain */
	1720
	1721	#define clean_parameter _glp_mpl_clean_parameter
	1722	void clean_parameter(MPL mpl, PARAMETER par);
	1723	/* clean model parameter */
	1724
	1725	/**********************************************************************/
	1726	/* * * MODEL VARIABLES * * */
	1727	/**********************************************************************/
	1728
	1729	struct 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
	1758	ELEMVAR 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
	1766	ELEMVAR 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
	1774	void eval_whole_var(MPL mpl, VARIABLE var);
	1775	/* evaluate model variable over entire domain */
	1776
	1777	#define clean_variable _glp_mpl_clean_variable
	1778	void clean_variable(MPL mpl, VARIABLE var);
	1779	/* clean model variable */
	1780
	1781	/**********************************************************************/
	1782	/* * * MODEL CONSTRAINTS AND OBJECTIVES * * */
	1783	/**********************************************************************/
	1784
	1785	struct 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
	1816	ELEMCON 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
	1824	ELEMCON 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
	1832	void eval_whole_con(MPL mpl, CONSTRAINT con);
	1833	/* evaluate model constraint over entire domain */
	1834
	1835	#define clean_constraint _glp_mpl_clean_constraint
	1836	void clean_constraint(MPL mpl, CONSTRAINT con);
	1837	/* clean model constraint */
	1838
	1839	/**********************************************************************/
	1840	/* * * DATA TABLES * * */
	1841	/**********************************************************************/
	1842
	1843	struct 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
	1873	struct 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
	1881	struct 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
	1889	struct 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
	1899	struct 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
	1909	struct 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
	1935	int mpl_tab_num_args(TABDCA *dca);
	1936
	1937	#define mpl_tab_get_arg _glp_mpl_tab_get_arg
	1938	const char mpl_tab_get_arg(TABDCA dca, int k);
	1939
	1940	#define mpl_tab_num_flds _glp_mpl_tab_num_flds
	1941	int mpl_tab_num_flds(TABDCA *dca);
	1942
	1943	#define mpl_tab_get_name _glp_mpl_tab_get_name
	1944	const char mpl_tab_get_name(TABDCA dca, int k);
	1945
	1946	#define mpl_tab_get_type _glp_mpl_tab_get_type
	1947	int mpl_tab_get_type(TABDCA *dca, int k);
	1948
	1949	#define mpl_tab_get_num _glp_mpl_tab_get_num
	1950	double mpl_tab_get_num(TABDCA *dca, int k);
	1951
	1952	#define mpl_tab_get_str _glp_mpl_tab_get_str
	1953	const char mpl_tab_get_str(TABDCA dca, int k);
	1954
	1955	#define mpl_tab_set_num _glp_mpl_tab_set_num
	1956	void mpl_tab_set_num(TABDCA *dca, int k, double num);
	1957
	1958	#define mpl_tab_set_str _glp_mpl_tab_set_str
	1959	void mpl_tab_set_str(TABDCA dca, int k, const char str);
	1960
	1961	#define mpl_tab_drv_open _glp_mpl_tab_drv_open
	1962	void mpl_tab_drv_open(MPL *mpl, int mode);
	1963
	1964	#define mpl_tab_drv_read _glp_mpl_tab_drv_read
	1965	int mpl_tab_drv_read(MPL *mpl);
	1966
	1967	#define mpl_tab_drv_write _glp_mpl_tab_drv_write
	1968	void mpl_tab_drv_write(MPL *mpl);
	1969
	1970	#define mpl_tab_drv_close _glp_mpl_tab_drv_close
	1971	void mpl_tab_drv_close(MPL *mpl);
	1972
	1973	/**********************************************************************/
	1974	/* * * PSEUDO-CODE * * */
	1975	/**********************************************************************/
	1976
	1977	union 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
	2063	struct 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
	2071	struct 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
	2211	double eval_numeric(MPL mpl, CODE code);
	2212	/* evaluate pseudo-code to determine numeric value */
	2213
	2214	#define eval_symbolic _glp_mpl_eval_symbolic
	2215	SYMBOL eval_symbolic(MPL mpl, CODE *code);
	2216	/* evaluate pseudo-code to determine symbolic value */
	2217
	2218	#define eval_logical _glp_mpl_eval_logical
	2219	int eval_logical(MPL mpl, CODE code);
	2220	/* evaluate pseudo-code to determine logical value */
	2221
	2222	#define eval_tuple _glp_mpl_eval_tuple
	2223	TUPLE eval_tuple(MPL mpl, CODE *code);
	2224	/* evaluate pseudo-code to construct n-tuple */
	2225
	2226	#define eval_elemset _glp_mpl_eval_elemset
	2227	ELEMSET eval_elemset(MPL mpl, CODE *code);
	2228	/* evaluate pseudo-code to construct elemental set */
	2229
	2230	#define is_member _glp_mpl_is_member
	2231	int 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
	2235	FORMULA eval_formula(MPL mpl, CODE *code);
	2236	/* evaluate pseudo-code to construct linear form */
	2237
	2238	#define clean_code _glp_mpl_clean_code
	2239	void clean_code(MPL mpl, CODE code);
	2240	/* clean pseudo-code */
	2241
	2242	/**********************************************************************/
	2243	/* * * MODEL STATEMENTS * * */
	2244	/**********************************************************************/
	2245
	2246	struct 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
	2254	struct 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
	2262	struct 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
	2289	struct 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
	2304	struct 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
	2312	struct 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
	2321	struct 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
	2356	void execute_table(MPL mpl, TABLE tab);
	2357	/* execute table statement */
	2358
	2359	#define free_dca _glp_mpl_free_dca
	2360	void free_dca(MPL *mpl);
	2361	/* free table driver communucation area */
	2362
	2363	#define clean_table _glp_mpl_clean_table
	2364	void clean_table(MPL mpl, TABLE tab);
	2365	/* clean table statement */
	2366
	2367	#define execute_check _glp_mpl_execute_check
	2368	void execute_check(MPL mpl, CHECK chk);
	2369	/* execute check statement */
	2370
	2371	#define clean_check _glp_mpl_clean_check
	2372	void clean_check(MPL mpl, CHECK chk);
	2373	/* clean check statement */
	2374
	2375	#define execute_display _glp_mpl_execute_display
	2376	void execute_display(MPL mpl, DISPLAY dpy);
	2377	/* execute display statement */
	2378
	2379	#define clean_display _glp_mpl_clean_display
	2380	void clean_display(MPL mpl, DISPLAY dpy);
	2381	/* clean display statement */
	2382
	2383	#define execute_printf _glp_mpl_execute_printf
	2384	void execute_printf(MPL mpl, PRINTF prt);
	2385	/* execute printf statement */
	2386
	2387	#define clean_printf _glp_mpl_clean_printf
	2388	void clean_printf(MPL mpl, PRINTF prt);
	2389	/* clean printf statement */
	2390
	2391	#define execute_for _glp_mpl_execute_for
	2392	void execute_for(MPL mpl, FOR fur);
	2393	/* execute for statement */
	2394
	2395	#define clean_for _glp_mpl_clean_for
	2396	void clean_for(MPL mpl, FOR fur);
	2397	/* clean for statement */
	2398
	2399	#define execute_statement _glp_mpl_execute_statement
	2400	void execute_statement(MPL mpl, STATEMENT stmt);
	2401	/* execute specified model statement */
	2402
	2403	#define clean_statement _glp_mpl_clean_statement
	2404	void 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
	2412	void alloc_content(MPL *mpl);
	2413	/* allocate content arrays for all model objects */
	2414
	2415	#define generate_model _glp_mpl_generate_model
	2416	void generate_model(MPL *mpl);
	2417	/* generate model */
	2418
	2419	#define build_problem _glp_mpl_build_problem
	2420	void build_problem(MPL *mpl);
	2421	/* build problem instance */
	2422
	2423	#define postsolve_model _glp_mpl_postsolve_model
	2424	void postsolve_model(MPL *mpl);
	2425	/* postsolve model */
	2426
	2427	#define clean_model _glp_mpl_clean_model
	2428	void clean_model(MPL *mpl);
	2429	/* clean model content */
	2430
	2431	/**********************************************************************/
	2432	/* * * INPUT/OUTPUT * * */
	2433	/**********************************************************************/
	2434
	2435	#define open_input _glp_mpl_open_input
	2436	void open_input(MPL mpl, char file);
	2437	/* open input text file */
	2438
	2439	#define read_char _glp_mpl_read_char
	2440	int read_char(MPL *mpl);
	2441	/* read next character from input text file */
	2442
	2443	#define close_input _glp_mpl_close_input
	2444	void close_input(MPL *mpl);
	2445	/* close input text file */
	2446
	2447	#define open_output _glp_mpl_open_output
	2448	void open_output(MPL mpl, char file);
	2449	/* open output text file */
	2450
	2451	#define write_char _glp_mpl_write_char
	2452	void write_char(MPL *mpl, int c);
	2453	/* write next character to output text file */
	2454
	2455	#define write_text _glp_mpl_write_text
	2456	void write_text(MPL mpl, char fmt, ...);
	2457	/* format and write text to output text file */
	2458
	2459	#define flush_output _glp_mpl_flush_output
	2460	void 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
	2482	void error(MPL mpl, char fmt, ...);
	2483	/* print error message and terminate model processing */
	2484
	2485	#define warning _glp_mpl_warning
	2486	void warning(MPL mpl, char fmt, ...);
	2487	/* print warning message and continue model processing */
	2488
	2489	#define mpl_initialize _glp_mpl_initialize
	2490	MPL *mpl_initialize(void);
	2491	/* create and initialize translator database */
	2492
	2493	#define mpl_read_model _glp_mpl_read_model
	2494	int 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
	2498	int mpl_read_data(MPL mpl, char file);
	2499	/* read data section */
	2500
	2501	#define mpl_generate _glp_mpl_generate
	2502	int mpl_generate(MPL mpl, char file);
	2503	/* generate model */
	2504
	2505	#define mpl_get_prob_name _glp_mpl_get_prob_name
	2506	char mpl_get_prob_name(MPL mpl);
	2507	/* obtain problem (model) name */
	2508
	2509	#define mpl_get_num_rows _glp_mpl_get_num_rows
	2510	int mpl_get_num_rows(MPL *mpl);
	2511	/* determine number of rows */
	2512
	2513	#define mpl_get_num_cols _glp_mpl_get_num_cols
	2514	int mpl_get_num_cols(MPL *mpl);
	2515	/* determine number of columns */
	2516
	2517	#define mpl_get_row_name _glp_mpl_get_row_name
	2518	char mpl_get_row_name(MPL mpl, int i);
	2519	/* obtain row name */
	2520
	2521	#define mpl_get_row_kind _glp_mpl_get_row_kind
	2522	int mpl_get_row_kind(MPL *mpl, int i);
	2523	/* determine row kind */
	2524
	2525	#define mpl_get_row_bnds _glp_mpl_get_row_bnds
	2526	int 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
	2530	int 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
	2534	double 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
	2538	char mpl_get_col_name(MPL mpl, int j);
	2539	/* obtain column name */
	2540
	2541	#define mpl_get_col_kind _glp_mpl_get_col_kind
	2542	int mpl_get_col_kind(MPL *mpl, int j);
	2543	/* determine column kind */
	2544
	2545	#define mpl_get_col_bnds _glp_mpl_get_col_bnds
	2546	int 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
	2550	int 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
	2555	void 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
	2562	void 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
	2569	void mpl_put_col_value(MPL *mpl, int j, double val);
	2570	/* store column value */
	2571	#endif
	2572
	2573	#define mpl_postsolve _glp_mpl_postsolve
	2574	int mpl_postsolve(MPL *mpl);
	2575	/* postsolve model */
	2576
	2577	#define mpl_terminate _glp_mpl_terminate
	2578	void 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.

Context Navigation

source: lemon-project-template-glpk/deps/glpk/src/glpmpl.h

Download in other formats: