Scippy

SCIP

Solving Constraint Integer Programs

reader_cip.c
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file reader_cip.c
26 * @ingroup DEFPLUGINS_READER
27 * @brief CIP file reader
28 * @author Stefan Heinz
29 * @author Marc Pfetsch
30 * @author Michael Winkler
31 *
32 */
33
34/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
35
37#include "scip/cons_linear.h"
38#include "scip/pub_fileio.h"
39#include "scip/pub_message.h"
40#include "scip/pub_misc.h"
41#include "scip/pub_reader.h"
42#include "scip/pub_var.h"
43#include "scip/reader_cip.h"
44#include "scip/scip_cons.h"
45#include "scip/scip_mem.h"
46#include "scip/scip_message.h"
47#include "scip/scip_numerics.h"
48#include "scip/scip_param.h"
49#include "scip/scip_prob.h"
50#include "scip/scip_reader.h"
51#include "scip/scip_var.h"
52#if !defined(_WIN32) && !defined(_WIN64)
53#include <strings.h> /*lint --e{766}*/ /* needed for strncasecmp() */
54#endif
55
56
57#define READER_NAME "cipreader"
58#define READER_DESC "file reader for CIP (Constraint Integer Program) format"
59#define READER_EXTENSION "cip"
60
61#define DEFAULT_CIP_WRITEFIXEDVARS TRUE /**< Should fixed and aggregated variables be written when writing? */
62
63
64/** CIP reading data */
65struct SCIP_ReaderData
66{
67 SCIP_Bool writefixedvars; /**< Should fixed and aggregated variables be written when writing? */
68};
69
70
71/** Section of the in CIP files */
73{
74 CIP_START, /**< start tag */
75 CIP_STATISTIC, /**< statistics section */
76 CIP_OBJECTIVE, /**< objective */
77 CIP_VARS, /**< list of (free) variables */
78 CIP_FIXEDVARS, /**< list of fixed variables */
79 CIP_CONSTRAINTS, /**< constraints */
80 CIP_END /**< end of file tag */
81};
82typedef enum CipSection CIPSECTION; /**< Section of the in CIP files */
83
84
85/*
86 * Data structures
87 */
88
89/** CIP reading data */
90struct CipInput
91{
92 SCIP_FILE* file; /**< input file */
93 char* strbuf; /**< string buffer for input lines */
94 int len; /**< length of strbuf */
95 int readingsize; /**< size of block in which len is increased if necessary */
96 int linenumber; /**< number of line in input file */
97 CIPSECTION section; /**< current section */
98 SCIP_Bool haserror; /**< some error occurred */
99 SCIP_Bool endfile; /**< we have reached the end of the file */
100};
101typedef struct CipInput CIPINPUT; /**< CIP reading data */
102
103
104/*
105 * Local methods for reading/parsing
106 */
107
108/** get next input line; this are all characters until the next semicolon */
109static
111 SCIP* scip, /**< SCIP data structure */
112 CIPINPUT* cipinput /**< CIP parsing data */
113 )
114{
115 char* endline;
116 char* endcharacter;
117 char* windowsendlinechar;
118
119 assert(cipinput != NULL);
120
121 /* read next line */
122 cipinput->endfile = (SCIPfgets(cipinput->strbuf, cipinput->len, cipinput->file) == NULL);
123
124 if( cipinput->endfile )
125 {
126 /* clear the line for safety reason */
127 BMSclearMemoryArray(cipinput->strbuf, cipinput->len);
128 return SCIP_OKAY;
129 }
130
131 cipinput->linenumber++;
132 endline = strchr(cipinput->strbuf, '\n');
133 endcharacter = strchr(cipinput->strbuf, ';');
134
135 while( endline == NULL || (endcharacter == NULL && cipinput->section == CIP_CONSTRAINTS && strncmp(cipinput->strbuf, "END", 3) != 0 ) )
136 {
137 int pos;
138
139 /* we refill the buffer from the '\n' character */
140 if( endline == NULL )
141 pos = cipinput->len - 1;
142 else
143 pos = (int) (endline - cipinput->strbuf);
144
145 /* don't erase the '\n' from all buffers for constraints */
146 if( endline != NULL && cipinput->section == CIP_CONSTRAINTS )
147 pos++;
148
149 /* if necessary reallocate memory */
150 if( pos + cipinput->readingsize >= cipinput->len )
151 {
152 cipinput->len = SCIPcalcMemGrowSize(scip, pos + cipinput->readingsize);
153 SCIP_CALL( SCIPreallocBufferArray(scip, &(cipinput->strbuf), cipinput->len) );
154 }
155
156 /* read next line */
157 cipinput->endfile = (SCIPfgets(&(cipinput->strbuf[pos]), cipinput->len - pos, cipinput->file) == NULL);
158
159 if( cipinput->endfile )
160 {
161 /* clear the line for safety reason */
162 BMSclearMemoryArray(cipinput->strbuf, cipinput->len);
163 return SCIP_OKAY;
164 }
165
166 cipinput->linenumber++;
167 endline = strrchr(&cipinput->strbuf[pos], '\n');
168 endcharacter = strchr(&cipinput->strbuf[pos], ';');
169 }
170 assert(endline != NULL);
171
172 /*SCIPdebugMsg(scip, "read line: %s\n", cipinput->strbuf);*/
173
174 /* check for windows "carriage return" endline character */
175 windowsendlinechar = strrchr(cipinput->strbuf, '\r');
176 if( windowsendlinechar != NULL && windowsendlinechar + 1 == endline )
177 --endline;
178 else
179 /* if the assert should not hold we found a windows "carriage return" which was not at the end of the line */
180 assert(windowsendlinechar == NULL);
181
182 if( cipinput->section == CIP_CONSTRAINTS && endcharacter != NULL && endline - endcharacter != 1 )
183 {
184 SCIPerrorMessage("Constraint line has to end with ';\\n' (line: %d).\n", cipinput->linenumber);
185 cipinput->haserror = TRUE;
186 return SCIP_OKAY; /* return error at hightest level */
187 }
188
189 *endline = '\0';
190
191 return SCIP_OKAY;
192}
193
194/** read the problem name out of the statistics */
195static
197 SCIP* scip, /**< SCIP data structure */
198 CIPINPUT* cipinput /**< CIP parsing data */
199 )
200{
201 char* buf;
202
203 assert(scip != NULL);
204
205 buf = cipinput->strbuf;
206
207 if( strncmp(buf, "STATISTICS", 9) == 0 )
208 {
209 cipinput->section = CIP_STATISTIC;
210 return;
211 }
212
213 if( strncmp(buf, "VARIABLES", 8) == 0 || strncmp(buf, "FIXED", 5) == 0 || strncmp(buf, "CONSTRAINTS", 11) == 0 || strncmp(buf, "OBJECTIVE", 9) == 0 )
214 {
215 SCIPerrorMessage("Syntax Error: File has to start with 'STATISTICS' section.\n");
216 cipinput->haserror = TRUE;
217 }
218}
219
220
221/** read the problem name out of the statistics */
222static
224 SCIP* scip, /**< SCIP data structure */
225 CIPINPUT* cipinput /**< CIP parsing data */
226 )
227{
228 char* buf;
229
230 buf = cipinput->strbuf;
231
232 if( strncmp(buf, "OBJECTIVE", 9) == 0 )
233 {
234 cipinput->section = CIP_OBJECTIVE;
235 return SCIP_OKAY;
236 }
237
238 SCIPdebugMsg(scip, "parse statistics\n");
239
240 if( strncmp(buf, " Problem name", 14) == 0 )
241 {
242 char* name;
243 char* s;
244
245 name = strchr(buf, ':');
246
247 if( name == NULL )
248 {
249 SCIPwarningMessage(scip, "did not find problem name (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
250 return SCIP_OKAY; /* no error, might work with empty problem name */
251 }
252
253 /* skip ':' */
254 ++name;
255
256 /* make sure that we terminate the string at comments ('#') or newline ('\r', '\n')*/
257 if( NULL != (s = strpbrk(name, "#\r\n")) )
258 *s = '\0';
259
260 /* remove white space (tabs, ' ') in front of the name */
261 SCIP_CALL( SCIPskipSpace(&name) );
262
263 /* set problem name */
265
266 SCIPdebugMsg(scip, "problem name <%s>\n", name);
267 }
268
269 return SCIP_OKAY;
270}
271
272/** read objective sense, offset, and scale */
273static
275 SCIP* scip, /**< SCIP data structure */
276 CIPINPUT* cipinput, /**< CIP parsing data */
277 SCIP_Real* objscale, /**< buffer where to multiply with objective scale */
278 SCIP_Real* objoffset /**< buffer where to add with objective offset */
279 )
280{
281 char* buf;
282 char* name;
283
284 assert(objscale != NULL);
285 assert(objoffset != NULL);
286
287 buf = cipinput->strbuf;
288
289 if( strncmp(buf, "VARIABLES", 8) == 0 )
290 cipinput->section = CIP_VARS;
291 else if( strncmp(buf, "FIXED", 5) == 0 )
292 cipinput->section = CIP_FIXEDVARS;
293 else if( strncmp(buf, "CONSTRAINTS", 11) == 0 )
294 cipinput->section = CIP_CONSTRAINTS;
295 else if( strncmp(buf, "END", 3) == 0 )
296 cipinput->section = CIP_END;
297
298 if( cipinput->section != CIP_OBJECTIVE )
299 return SCIP_OKAY;
300
301 SCIPdebugMsg(scip, "parse objective information\n");
302
303 /* remove white space */
304 SCIP_CALL( SCIPskipSpace(&buf) );
305
306 if( strncasecmp(buf, "Sense", 5) == 0 )
307 {
308 SCIP_OBJSENSE objsense;
309
310 name = strchr(buf, ':');
311
312 if( name == NULL )
313 {
314 SCIPwarningMessage(scip, "did not find objective sense (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
315 return SCIP_OKAY; /* no error - might work with default */
316 }
317
318 /* skip ':' */
319 ++name;
320
321 /* remove white space in front of the name */
322 SCIP_CALL( SCIPskipSpace(&name) );
323
324 if( strncasecmp(name, "minimize", 3) == 0 )
325 objsense = SCIP_OBJSENSE_MINIMIZE;
326 else if( strncasecmp(name, "maximize", 3) == 0 )
327 objsense = SCIP_OBJSENSE_MAXIMIZE;
328 else
329 {
330 SCIPwarningMessage(scip, "unknown objective sense '%s' (line: %d):\n%s\n", name, cipinput->linenumber, cipinput->strbuf);
331 return SCIP_OKAY; /* no error - might work with default */
332 }
333
334 /* set problem name */
335 SCIP_CALL( SCIPsetObjsense(scip, objsense) );
336 SCIPdebugMsg(scip, "objective sense <%s>\n", objsense == SCIP_OBJSENSE_MINIMIZE ? "minimize" : "maximize");
337 }
338 else if( strncasecmp(buf, "Offset", 6) == 0 )
339 {
340 SCIP_Real off = 0;
341 char* endptr;
342
343 name = strchr(buf, ':');
344
345 if( name == NULL )
346 {
347 SCIPwarningMessage(scip, "did not find offset (line: %d)\n", cipinput->linenumber);
348 return SCIP_OKAY;
349 }
350
351 /* skip ':' */
352 ++name;
353
354 /* remove white space in front of the name */
355 SCIP_CALL( SCIPskipSpace(&name) );
356
357 if ( SCIPstrToRealValue(name, &off, &endptr) )
358 {
359 *objoffset += off;
360 SCIPdebugMsg(scip, "offset <%g> (total: %g)\n", off, *objoffset);
361 }
362 else
363 {
364 SCIPwarningMessage(scip, "could not parse offset (line: %d)\n%s\n", cipinput->linenumber, cipinput->strbuf);
365 return SCIP_OKAY;
366 }
367 }
368 else if( strncasecmp(buf, "Scale", 5) == 0 )
369 {
370 SCIP_Real scale = 1.0;
371 char* endptr;
372
373 name = strchr(buf, ':');
374
375 if( name == NULL )
376 {
377 SCIPwarningMessage(scip, "did not find scale (line: %d)\n", cipinput->linenumber);
378 return SCIP_OKAY;
379 }
380
381 /* skip ':' */
382 ++name;
383
384 /* remove white space in front of the name */
385 SCIP_CALL( SCIPskipSpace(&name) );
386
387 if ( SCIPstrToRealValue(name, &scale, &endptr) )
388 {
389 *objscale *= scale;
390 SCIPdebugMsg(scip, "objscale <%g> (total: %g)\n", scale, *objscale);
391 }
392 else
393 {
394 SCIPwarningMessage(scip, "could not parse objective scale (line: %d)\n%s\n", cipinput->linenumber, cipinput->strbuf);
395 return SCIP_OKAY;
396 }
397 }
398
399 return SCIP_OKAY;
400}
401
402/** read variable */
403static
405 SCIP* scip, /**< SCIP data structure */
406 CIPINPUT* cipinput, /**< CIP parsing data */
407 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
408 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
409 SCIP_Real objscale /**< objective scale */
410 )
411{
412 SCIP_Bool success;
413 SCIP_VAR* var;
414 char* buf;
415 char* endptr;
416
417 buf = cipinput->strbuf;
418
419 if( strncmp(buf, "FIXED", 5) == 0 )
420 cipinput->section = CIP_FIXEDVARS;
421 else if( strncmp(buf, "CONSTRAINTS", 4) == 0 )
422 cipinput->section = CIP_CONSTRAINTS;
423 else if( strncmp(buf, "END", 3) == 0 )
424 cipinput->section = CIP_END;
425
426 if( cipinput->section != CIP_VARS )
427 return SCIP_OKAY;
428
429 SCIPdebugMsg(scip, "parse variable\n");
430
431 /* parse the variable */
432 SCIP_CALL( SCIPparseVar(scip, &var, buf, initial, removable, NULL, NULL, NULL, NULL, NULL, &endptr, &success) );
433
434 if( !success )
435 {
436 SCIPerrorMessage("syntax error in variable information (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
437 cipinput->haserror = TRUE;
438 return SCIP_OKAY;
439 }
440
441 if( objscale != 1.0 )
442 {
443 SCIP_CALL( SCIPchgVarObj(scip, var, SCIPvarGetObj(var) * objscale) );
444 }
445
446 SCIP_CALL( SCIPaddVar(scip, var) );
447
449
450 SCIP_CALL( SCIPreleaseVar(scip, &var) );
451
452 return SCIP_OKAY;
453}
454
455/** read fixed variable */
456static
458 SCIP* scip, /**< SCIP data structure */
459 CIPINPUT* cipinput /**< CIP parsing data */
460 )
461{
462 SCIP_Bool success;
463 SCIP_VAR* var;
464 char* buf;
465 char* endptr;
466 char name[SCIP_MAXSTRLEN];
467
468 buf = cipinput->strbuf;
469
470 if( strncmp(buf, "CONSTRAINTS", 11) == 0 )
471 cipinput->section = CIP_CONSTRAINTS;
472 else if( strncmp(buf, "END", 3) == 0 )
473 cipinput->section = CIP_END;
474
475 if( cipinput->section != CIP_FIXEDVARS )
476 return SCIP_OKAY;
477
478 SCIPdebugMsg(scip, "parse fixed variable\n");
479
480 /* parse the variable */
481 SCIP_CALL( SCIPparseVar(scip, &var, buf, TRUE, FALSE, NULL, NULL, NULL, NULL, NULL, &endptr, &success) );
482
483 if( !success )
484 {
485 SCIPerrorMessage("syntax error in variable information (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
486 cipinput->haserror = TRUE;
487 return SCIP_OKAY;
488 }
489
490 /* skip intermediate stuff */
491 buf = endptr;
492
493 while ( *buf != '\0' && (*buf == ' ' || *buf == ',') )
494 ++buf;
495
496 /* check whether variable is fixed */
497 if ( strncmp(buf, "fixed:", 6) == 0 )
498 {
499 SCIP_CALL( SCIPaddVar(scip, var) );
501 }
502 else if ( strncmp(buf, "negated:", 8) == 0 )
503 {
504 SCIP_CONS* lincons;
505 SCIP_VAR* negvar;
506 SCIP_Real vals[2];
507 SCIP_VAR* vars[2];
508
509 buf += 8;
510
511 /* we can just parse the next variable (ignoring all other information in between) */
512 SCIP_CALL( SCIPparseVarName(scip, buf, &negvar, &endptr) );
513
514 if ( negvar == NULL )
515 {
516 SCIPerrorMessage("could not parse negated variable (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
517 cipinput->haserror = TRUE;
518 return SCIP_OKAY;
519 }
520
521 assert(SCIPvarIsBinary(var));
522 assert(SCIPvarIsBinary(negvar));
523
524 SCIP_CALL( SCIPaddVar(scip, var) );
525
526 SCIPdebugMsg(scip, "creating negated variable <%s> (of <%s>) ...\n", SCIPvarGetName(var), SCIPvarGetName(negvar) );
528
529 /* add linear constraint for negation */
530 (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "neg_%s", SCIPvarGetName(var) );
531 vars[0] = var;
532 vars[1] = negvar;
533 vals[0] = 1.0;
534 vals[1] = 1.0;
535 SCIPdebugMsg(scip, "coupling constraint:\n");
536 SCIP_CALL( SCIPcreateConsLinear(scip, &lincons, name, 2, vars, vals, 1.0, 1.0, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE) );
537 SCIPdebugPrintCons(scip, lincons, NULL);
538 SCIP_CALL( SCIPaddCons(scip, lincons) );
539 SCIP_CALL( SCIPreleaseCons(scip, &lincons) );
540 }
541 else if ( strncmp(buf, "aggregated:", 11) == 0 )
542 {
543 /* handle (multi-)aggregated variables */
544 SCIP_CONS* lincons;
545 SCIP_Real* vals;
546 SCIP_VAR** vars;
547 SCIP_Real rhs = 0.0;
548 const char* str;
549 int nvarssize = 20;
550 int requsize;
551 int nvars;
552
553 buf += 11;
554
555 SCIPdebugMsg(scip, "parsing aggregated variable <%s> ...\n", SCIPvarGetName(var));
556
557 /* first parse constant */
558 if ( ! SCIPstrToRealValue(buf, &rhs, &endptr) )
559 {
560 SCIPerrorMessage("expected constant when aggregated variable information (line: %d):\n%s\n", cipinput->linenumber, buf);
561 cipinput->haserror = TRUE;
562 return SCIP_OKAY;
563 }
564
565 /* check whether constant is 0.0 */
566 str = endptr;
567 SCIP_CALL( SCIPskipSpace((char**)&str) );
568 /* if next char is '<' we found a variable -> constant is 0 */
569 if ( *str != '<' )
570 {
571 SCIPdebugMsg(scip, "constant: %f\n", rhs);
572 buf = endptr;
573 }
574 else
575 {
576 /* otherwise keep buf */
577 rhs = 0.0;
578 }
579
580 /* initialize buffers for storing the variables and values */
581 SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvarssize) );
582 SCIP_CALL( SCIPallocBufferArray(scip, &vals, nvarssize) );
583
584 vars[0] = var;
585 vals[0] = -1.0;
586 --nvarssize;
587
588 /* parse linear sum to get variables and coefficients */
589 SCIP_CALL( SCIPparseVarsLinearsum(scip, buf, &(vars[1]), &(vals[1]), &nvars, nvarssize, &requsize, &endptr, &success) );
590 if ( success && requsize > nvarssize )
591 {
592 /* realloc buffers and try again */
593 nvarssize = requsize;
594 SCIP_CALL( SCIPreallocBufferArray(scip, &vars, nvarssize + 1) );
595 SCIP_CALL( SCIPreallocBufferArray(scip, &vals, nvarssize + 1) );
596
597 SCIP_CALL( SCIPparseVarsLinearsum(scip, buf, &(vars[1]), &(vals[1]), &nvars, nvarssize, &requsize, &endptr, &success) );
598 assert( ! success || requsize <= nvarssize); /* if successful, then should have had enough space now */
599 }
600
601 if( success )
602 {
603 /* add aggregated variable */
604 SCIP_CALL( SCIPaddVar(scip, var) );
605
606 /* special handling of variables that seem to be slack variables of indicator constraints */
607 str = SCIPvarGetName(var);
608 if ( strncmp(str, "indslack", 8) == 0 )
609 {
610 (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "indlin");
611 (void) strncat(name, str+8, SCIP_MAXSTRLEN-7);
612 }
613 else if ( strncmp(str, "t_indslack", 10) == 0 )
614 {
615 (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "indlin");
616 (void) strncat(name, str+10, SCIP_MAXSTRLEN-7);
617 }
618 else
619 (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "%s", SCIPvarGetName(var) );
620
621 /* add linear constraint for (multi-)aggregation */
622 SCIPdebugMsg(scip, "coupling constraint:\n");
623 SCIP_CALL( SCIPcreateConsLinear(scip, &lincons, name, nvars + 1, vars, vals, -rhs, -rhs, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE) );
624 SCIPdebugPrintCons(scip, lincons, NULL);
625 SCIP_CALL( SCIPaddCons(scip, lincons) );
626 SCIP_CALL( SCIPreleaseCons(scip, &lincons) );
627 }
628 else
629 {
630 SCIPwarningMessage(scip, "Could not read (multi-)aggregated variable <%s>: dependent variables unkown - consider changing the order (line: %d):\n%s\n",
631 SCIPvarGetName(var), cipinput->linenumber, buf);
632 }
633
636 }
637 else
638 {
639 SCIPerrorMessage("unknown section when parsing variables (line: %d):\n%s\n", cipinput->linenumber, buf);
640 cipinput->haserror = TRUE;
641 return SCIP_OKAY;
642 }
643 SCIP_CALL( SCIPreleaseVar(scip, &var) );
644
645 return SCIP_OKAY;
646}
647
648/** read constraint */
649static
651 SCIP* scip, /**< SCIP data structure */
652 CIPINPUT* cipinput, /**< CIP parsing data */
653 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
654 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
655 SCIP_Bool dynamic, /**< Is constraint subject to aging?
656 * Usually set to FALSE. Set to TRUE for own cuts which
657 * are separated as constraints. */
658 SCIP_Bool removable /**< should the relaxation be removed from the LP due to aging or cleanup?
659 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
660 )
661{
662 SCIP_CONS* cons;
663 char* buf;
664 char* copybuf;
665 SCIP_RETCODE retcode;
666 SCIP_Bool separate;
667 SCIP_Bool enforce;
668 SCIP_Bool check;
669 SCIP_Bool propagate;
670 SCIP_Bool local;
671 SCIP_Bool modifiable;
672 SCIP_Bool success;
673 int len;
674
675 buf = cipinput->strbuf;
676
677 if( strncmp(buf, "END", 3) == 0 )
678 {
679 cipinput->section = CIP_END;
680 return SCIP_OKAY;
681 }
682
683 SCIPdebugMsg(scip, "parse constraints in line %d\n", cipinput->linenumber);
684
685 separate = TRUE;
686 enforce = TRUE;
687 check = TRUE;
688 propagate = TRUE;
689 local = FALSE;
690 modifiable = FALSE;
691
692 /* get length of line and check for correct ending of constraint line */
693 len = (int)strlen(buf);
694 if( len < 1 )
695 {
696 SCIPerrorMessage("syntax error: expected constraint in line %d.\n", cipinput->linenumber);
697 cipinput->haserror = TRUE;
698 return SCIP_OKAY;
699 }
700 if ( buf[len - 1] != ';' )
701 {
702 SCIPerrorMessage("syntax error: line has to end with ';' (line: %d)\n", cipinput->linenumber);
703 cipinput->haserror = TRUE;
704 return SCIP_OKAY;
705 }
706
707 /* copy buffer for working purpose */
708 SCIP_CALL( SCIPduplicateBufferArray(scip, &copybuf, buf, len) );
709 copybuf[len - 1] = '\0';
710
711 /* parse the constraint */
712 retcode = SCIPparseCons(scip, &cons, copybuf,
713 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, FALSE, &success);
714
715 /* free temporary buffer */
716 SCIPfreeBufferArray(scip, &copybuf);
717
718 SCIP_CALL( retcode );
719
720 if( !success )
721 {
722 SCIPerrorMessage("syntax error when reading constraint (line: %d):\n%s\n", cipinput->linenumber, cipinput->strbuf);
723 cipinput->haserror = TRUE;
724 return SCIP_OKAY;
725 }
726
727 SCIP_CALL( SCIPaddCons(scip, cons) );
729 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
730
731 return SCIP_OKAY;
732}
733
734/*
735 * Callback methods of reader
736 */
737
738/** copy method for reader plugins (called when SCIP copies plugins) */
739static
741{ /*lint --e{715}*/
742 assert(scip != NULL);
743 assert(reader != NULL);
744 assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
745
746 /* call inclusion method of reader */
748
749 return SCIP_OKAY;
750}
751
752/** destructor of reader to free user data (called when SCIP is exiting) */
753static
755{
756 SCIP_READERDATA* readerdata;
757
758 assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
759 readerdata = SCIPreaderGetData(reader);
760 assert(readerdata != NULL);
761 SCIPfreeBlockMemory(scip, &readerdata);
762
763 return SCIP_OKAY;
764}
765
766
767/** problem reading method of reader */
768static
770{ /*lint --e{715}*/
771 CIPINPUT cipinput;
772 SCIP_Real objscale;
773 SCIP_Real objoffset;
774 SCIP_Bool initialconss;
775 SCIP_Bool dynamicconss;
776 SCIP_Bool dynamiccols;
777 SCIP_Bool dynamicrows;
778 SCIP_Bool initialvar;
779 SCIP_Bool removablevar;
780 SCIP_RETCODE retcode;
781
782 if( NULL == (cipinput.file = SCIPfopen(filename, "r")) )
783 {
784 SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
785 SCIPprintSysError(filename);
786 return SCIP_NOFILE;
787 }
788
789 cipinput.len = 131071;
790 SCIP_CALL( SCIPallocBufferArray(scip, &(cipinput.strbuf), cipinput.len) );
791
792 cipinput.linenumber = 0;
793 cipinput.section = CIP_START;
794 cipinput.haserror = FALSE;
795 cipinput.endfile = FALSE;
796 cipinput.readingsize = 65535;
797
799
800 SCIP_CALL( SCIPgetBoolParam(scip, "reading/initialconss", &initialconss) );
801 SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamiccols", &dynamiccols) );
802 SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicconss", &dynamicconss) );
803 SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicrows", &dynamicrows) );
804
805 initialvar = !dynamiccols;
806 removablevar = dynamiccols;
807
808 objscale = 1.0;
809 objoffset = 0.0;
810
811 while( cipinput.section != CIP_END && !cipinput.haserror )
812 {
813 /* get next input string */
814 SCIP_CALL( getInputString(scip, &cipinput) );
815
816 if( cipinput.endfile )
817 break;
818
819 switch( cipinput.section )
820 {
821 case CIP_START:
822 getStart(scip, &cipinput);
823 break;
824 case CIP_STATISTIC:
825 SCIP_CALL( getStatistics(scip, &cipinput) );
826 break;
827 case CIP_OBJECTIVE:
828 SCIP_CALL( getObjective(scip, &cipinput, &objscale, &objoffset) );
829 break;
830 case CIP_VARS:
831 retcode = getVariable(scip, &cipinput, initialvar, removablevar, objscale);
832
833 if( retcode == SCIP_READERROR )
834 {
835 cipinput.haserror = TRUE;
836 goto TERMINATE;
837 }
838 SCIP_CALL(retcode);
839
840 break;
841 case CIP_FIXEDVARS:
842 retcode = getFixedVariable(scip, &cipinput);
843
844 if( retcode == SCIP_READERROR )
845 {
846 cipinput.haserror = TRUE;
847 goto TERMINATE;
848 }
849 SCIP_CALL(retcode);
850
851 break;
852 case CIP_CONSTRAINTS:
853 retcode = getConstraint(scip, &cipinput, initialconss, dynamicconss, dynamicrows);
854
855 if( retcode == SCIP_READERROR )
856 {
857 cipinput.haserror = TRUE;
858 goto TERMINATE;
859 }
860 SCIP_CALL(retcode);
861
862 break;
863 default:
864 SCIPerrorMessage("invalid CIP state\n");
865 SCIPABORT();
866 return SCIP_INVALIDDATA; /*lint !e527*/
867 } /*lint !e788*/
868 }
869
870 if( !SCIPisZero(scip, objoffset) && !cipinput.haserror )
871 {
872 SCIP_VAR* objoffsetvar;
873
874 objoffset *= objscale;
875 SCIP_CALL( SCIPcreateVar(scip, &objoffsetvar, "objoffset", objoffset, objoffset, 1.0, SCIP_VARTYPE_CONTINUOUS,
876 TRUE, TRUE, NULL, NULL, NULL, NULL, NULL) );
877 SCIP_CALL( SCIPaddVar(scip, objoffsetvar) );
878 SCIP_CALL( SCIPreleaseVar(scip, &objoffsetvar) );
879 SCIPdebugMsg(scip, "added variables <objoffset> for objective offset of <%g>\n", objoffset);
880 }
881
882 if( cipinput.section != CIP_END && !cipinput.haserror )
883 {
884 SCIPerrorMessage("unexpected EOF\n");
885 }
886
887 TERMINATE:
888 /* close file stream */
889 SCIPfclose(cipinput.file);
890
891 SCIPfreeBufferArray(scip, &cipinput.strbuf);
892
893 if( cipinput.haserror )
894 return SCIP_READERROR;
895
896 /* successfully parsed cip format */
897 *result = SCIP_SUCCESS;
898 return SCIP_OKAY;
899}
900
901/** hash key retrieval function for variables */
902static
904{ /*lint --e{715}*/
905 return elem;
906}
907
908/** returns TRUE iff the indices of both variables are equal */
909static
911{ /*lint --e{715}*/
912 if( key1 == key2 )
913 return TRUE;
914 return FALSE;
915}
916
917/** returns the hash value of the key */
918static
920{ /*lint --e{715}*/
921 assert( SCIPvarGetIndex((SCIP_VAR*) key) >= 0 );
922 return (unsigned int) SCIPvarGetIndex((SCIP_VAR*) key);
923}
924
925/** problem writing method of reader */
926static
928{ /*lint --e{715}*/
929 SCIP_HASHTABLE* varhash = NULL;
930 SCIP_READERDATA* readerdata;
931 int i;
932
933 assert(reader != NULL);
934 assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
935
936 SCIPinfoMessage(scip, file, "STATISTICS\n");
937 SCIPinfoMessage(scip, file, " Problem name : %s\n", name);
938 SCIPinfoMessage(scip, file, " Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
939 nvars, nbinvars, nintvars, nimplvars, ncontvars);
940 SCIPinfoMessage(scip, file, " Constraints : %d initial, %d maximal\n", startnconss, maxnconss);
941
942 SCIPinfoMessage(scip, file, "OBJECTIVE\n");
943 SCIPinfoMessage(scip, file, " Sense : %s\n", objsense == SCIP_OBJSENSE_MINIMIZE ? "minimize" : "maximize");
944 if( !SCIPisZero(scip, objoffset) )
945 SCIPinfoMessage(scip, file, " Offset : %+.15g\n", objoffset);
946 if( !SCIPisEQ(scip, objscale, 1.0) )
947 SCIPinfoMessage(scip, file, " Scale : %.15g\n", objscale);
948
949 if ( nfixedvars > 0 )
950 {
951 /* set up hash table for variables that have been written property (used for writing out fixed vars in the right order) */
952 SCIP_CALL( SCIPhashtableCreate(&varhash, SCIPblkmem(scip), nvars + nfixedvars, hashGetKeyVar, hashKeyEqVar, hashKeyValVar, NULL) );
953 }
954
955 if ( nvars + nfixedvars > 0 )
956 {
957 SCIPinfoMessage(scip, file, "VARIABLES\n");
958 }
959
960 if( nvars > 0 )
961 {
962 for( i = 0; i < nvars; ++i )
963 {
964 SCIP_VAR* var;
965
966 var = vars[i];
967 assert( var != NULL );
968 SCIP_CALL( SCIPprintVar(scip, var, file) );
969 if ( varhash != NULL )
970 {
971 /* add free variable to hashtable */
972 if ( ! SCIPhashtableExists(varhash, (void*) var) )
973 {
974 SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
975 }
976 }
977 }
978 }
979
980 readerdata = SCIPreaderGetData(reader);
981 assert(readerdata != NULL);
982
983 if( readerdata->writefixedvars && nfixedvars > 0 )
984 {
985 int nwritten = 0;
986
987 SCIPinfoMessage(scip, file, "FIXED\n");
988
989 /* loop through variables until each has been written after the variables that it depends on have been written; this
990 * requires several runs over the variables, but the depth (= number of loops) is usually small. */
991 while ( nwritten < nfixedvars )
992 {
993 SCIPdebugMsg(scip, "written %d of %d fixed variables.\n", nwritten, nfixedvars);
994 for (i = 0; i < nfixedvars; ++i)
995 {
996 SCIP_VAR* var;
997 SCIP_VAR* tmpvar;
998
999 var = fixedvars[i];
1000 assert( var != NULL );
1001
1002 /* skip variables already written */
1003 if ( SCIPhashtableExists(varhash, (void*) var) )
1004 continue;
1005
1006 switch ( SCIPvarGetStatus(var) )
1007 {
1009
1010 /* fixed variables can simply be output and added to the hashtable */
1011 SCIP_CALL( SCIPprintVar(scip, var, file) );
1012 assert( ! SCIPhashtableExists(varhash, (void*) var) );
1013 SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
1014 ++nwritten;
1015
1016 break;
1017
1019
1020 tmpvar = SCIPvarGetNegationVar(var);
1021 assert( tmpvar != NULL );
1022 assert( var == SCIPvarGetNegatedVar(tmpvar) );
1023
1024 /* if the negated variable has been written, we can write the current variable */
1025 if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
1026 {
1027 SCIP_CALL( SCIPprintVar(scip, var, file) );
1028 assert( ! SCIPhashtableExists(varhash, (void*) var) );
1029 SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
1030 ++nwritten;
1031 }
1032 break;
1033
1035
1036 tmpvar = SCIPvarGetAggrVar(var);
1037 assert( tmpvar != NULL );
1038
1039 /* if the aggregating variable has been written, we can write the current variable */
1040 if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
1041 {
1042 SCIP_CALL( SCIPprintVar(scip, var, file) );
1043 assert( ! SCIPhashtableExists(varhash, (void*) var) );
1044 SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
1045 ++nwritten;
1046 }
1047 break;
1048
1050 {
1051 SCIP_VAR** aggrvars;
1052 int naggrvars;
1053 int j;
1054
1055 /* get the active representation */
1057
1058 naggrvars = SCIPvarGetMultaggrNVars(var);
1059 aggrvars = SCIPvarGetMultaggrVars(var);
1060 assert(aggrvars != NULL || naggrvars == 0);
1061
1062 for (j = 0; j < naggrvars; ++j)
1063 {
1064 if( !SCIPhashtableExists(varhash, (void*) aggrvars[j]) ) /*lint !e613*/
1065 break;
1066 }
1067
1068 /* if all multi-aggregating variables have been written, we can write the current variable */
1069 if ( j >= naggrvars )
1070 {
1071 SCIP_CALL( SCIPprintVar(scip, var, file) );
1072 assert( ! SCIPhashtableExists(varhash, (void*) var) );
1073 SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
1074 ++nwritten;
1075 }
1076 break;
1077 }
1078
1082 SCIPerrorMessage("Only fixed variables are allowed to be present in fixedvars list.\n");
1083 SCIPABORT();
1084 return SCIP_ERROR; /*lint !e527*/
1085 }
1086 }
1087 }
1088 }
1089
1090 if( nconss > 0 )
1091 {
1092 SCIPinfoMessage(scip, file, "CONSTRAINTS\n");
1093
1094 for( i = 0; i < nconss; ++i )
1095 {
1096 SCIP_CALL( SCIPprintCons(scip, conss[i], file) );
1097 SCIPinfoMessage(scip, file, ";\n");
1098 }
1099 }
1100 SCIPinfoMessage(scip, file, "END\n");
1101
1102 *result = SCIP_SUCCESS;
1103
1104 if( nfixedvars > 0 )
1105 SCIPhashtableFree(&varhash);
1106 else
1107 assert(varhash == NULL);
1108
1109 return SCIP_OKAY;
1110}
1111
1112
1113/*
1114 * reader specific interface methods
1115 */
1116
1117/** includes the cip file reader in SCIP */
1119 SCIP* scip /**< SCIP data structure */
1120 )
1121{
1122 SCIP_READERDATA* readerdata;
1123 SCIP_READER* reader;
1124
1125 /* create cip reader data */
1126 SCIP_CALL( SCIPallocBlockMemory(scip, &readerdata) );
1127
1128 /* include reader */
1130
1131 /* set non fundamental callbacks via setter functions */
1132 SCIP_CALL( SCIPsetReaderCopy(scip, reader, readerCopyCip) );
1133 SCIP_CALL( SCIPsetReaderFree(scip, reader, readerFreeCip) );
1134 SCIP_CALL( SCIPsetReaderRead(scip, reader, readerReadCip) );
1135 SCIP_CALL( SCIPsetReaderWrite(scip, reader, readerWriteCip) );
1136
1137 /* add cip reader parameters */
1139 "reading/cipreader/writefixedvars", "should fixed and aggregated variables be printed (if not, re-parsing might fail)",
1140 &readerdata->writefixedvars, FALSE, DEFAULT_CIP_WRITEFIXEDVARS, NULL, NULL) );
1141
1142 return SCIP_OKAY;
1143}
Constraint handler for linear constraints in their most general form, .
#define NULL
Definition: def.h:267
#define SCIP_MAXSTRLEN
Definition: def.h:288
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
#define TRUE
Definition: def.h:93
#define FALSE
Definition: def.h:94
#define SCIPABORT()
Definition: def.h:346
#define SCIP_CALL(x)
Definition: def.h:374
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
Definition: fileio.c:153
int SCIPfclose(SCIP_FILE *fp)
Definition: fileio.c:232
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
Definition: fileio.c:200
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPincludeReaderCip(SCIP *scip)
Definition: reader_cip.c:1118
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_prob.c:1668
SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
Definition: scip_prob.c:1095
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:2770
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip_prob.c:1242
SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
Definition: scip_prob.c:117
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
Definition: misc.c:2346
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
Definition: misc.c:2659
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
Definition: misc.c:2296
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
Definition: misc.c:2547
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
#define SCIPdebugMsg
Definition: scip_message.h:78
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:120
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:250
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:57
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip_cons.c:2537
SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: scip_cons.c:1082
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1174
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip_mem.c:139
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:124
#define SCIPreallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:128
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
#define SCIPduplicateBufferArray(scip, ptr, source, num)
Definition: scip_mem.h:132
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
Definition: scip_reader.c:109
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
Definition: scip_reader.c:147
SCIP_READERDATA * SCIPreaderGetData(SCIP_READER *reader)
Definition: reader.c:492
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
Definition: scip_reader.c:171
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:557
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
Definition: scip_reader.c:195
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
Definition: scip_reader.c:219
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
Definition: var.c:17894
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:17599
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:17538
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17926
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip_var.c:533
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:474
int SCIPvarGetIndex(SCIP_VAR *var)
Definition: var.c:17758
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17419
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1248
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip_var.c:704
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1693
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
Definition: var.c:17858
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
Definition: var.c:17846
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
Definition: var.c:17904
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:114
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip_var.c:9994
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4513
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
Definition: var.c:17810
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10877
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
Definition: misc.c:10977
void SCIPprintSysError(const char *message)
Definition: misc.c:10769
SCIP_RETCODE SCIPskipSpace(char **s)
Definition: misc.c:10866
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
Definition: memory.h:130
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:57
wrapper functions to map file i/o to standard or zlib file i/o
struct SCIP_File SCIP_FILE
Definition: pub_fileio.h:43
public methods for message output
#define SCIPerrorMessage
Definition: pub_message.h:64
#define SCIPdebug(x)
Definition: pub_message.h:93
#define SCIPdebugPrintCons(x, y, z)
Definition: pub_message.h:102
public data structures and miscellaneous methods
public methods for input file readers
public methods for problem variables
static SCIP_RETCODE getConstraint(SCIP *scip, CIPINPUT *cipinput, SCIP_Bool initial, SCIP_Bool dynamic, SCIP_Bool removable)
Definition: reader_cip.c:650
enum CipSection CIPSECTION
Definition: reader_cip.c:82
static SCIP_DECL_READERFREE(readerFreeCip)
Definition: reader_cip.c:754
static SCIP_RETCODE getInputString(SCIP *scip, CIPINPUT *cipinput)
Definition: reader_cip.c:110
static SCIP_DECL_HASHGETKEY(hashGetKeyVar)
Definition: reader_cip.c:903
static SCIP_RETCODE getObjective(SCIP *scip, CIPINPUT *cipinput, SCIP_Real *objscale, SCIP_Real *objoffset)
Definition: reader_cip.c:274
#define READER_DESC
Definition: reader_cip.c:58
static void getStart(SCIP *scip, CIPINPUT *cipinput)
Definition: reader_cip.c:196
static SCIP_DECL_READERCOPY(readerCopyCip)
Definition: reader_cip.c:740
CipSection
Definition: reader_cip.c:73
@ CIP_CONSTRAINTS
Definition: reader_cip.c:79
@ CIP_VARS
Definition: reader_cip.c:77
@ CIP_START
Definition: reader_cip.c:74
@ CIP_OBJECTIVE
Definition: reader_cip.c:76
@ CIP_FIXEDVARS
Definition: reader_cip.c:78
@ CIP_STATISTIC
Definition: reader_cip.c:75
@ CIP_END
Definition: reader_cip.c:80
static SCIP_DECL_READERREAD(readerReadCip)
Definition: reader_cip.c:769
static SCIP_RETCODE getStatistics(SCIP *scip, CIPINPUT *cipinput)
Definition: reader_cip.c:223
#define READER_EXTENSION
Definition: reader_cip.c:59
#define DEFAULT_CIP_WRITEFIXEDVARS
Definition: reader_cip.c:61
static SCIP_DECL_READERWRITE(readerWriteCip)
Definition: reader_cip.c:927
#define READER_NAME
Definition: reader_cip.c:57
static SCIP_DECL_HASHKEYEQ(hashKeyEqVar)
Definition: reader_cip.c:910
static SCIP_DECL_HASHKEYVAL(hashKeyValVar)
Definition: reader_cip.c:919
struct CipInput CIPINPUT
Definition: reader_cip.c:101
static SCIP_RETCODE getFixedVariable(SCIP *scip, CIPINPUT *cipinput)
Definition: reader_cip.c:457
static SCIP_RETCODE getVariable(SCIP *scip, CIPINPUT *cipinput, SCIP_Bool initial, SCIP_Bool removable, SCIP_Real objscale)
Definition: reader_cip.c:404
CIP file reader.
public methods for constraint handler plugins and constraints
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for reader plugins
public methods for SCIP variables
@ SCIP_OBJSENSE_MAXIMIZE
Definition: type_prob.h:47
@ SCIP_OBJSENSE_MINIMIZE
Definition: type_prob.h:48
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:50
struct SCIP_ReaderData SCIP_READERDATA
Definition: type_reader.h:53
@ SCIP_SUCCESS
Definition: type_result.h:58
@ SCIP_NOFILE
Definition: type_retcode.h:47
@ SCIP_READERROR
Definition: type_retcode.h:45
@ SCIP_INVALIDDATA
Definition: type_retcode.h:52
@ SCIP_OKAY
Definition: type_retcode.h:42
@ SCIP_ERROR
Definition: type_retcode.h:43
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
@ SCIP_VARTYPE_CONTINUOUS
Definition: type_var.h:71
@ SCIP_VARSTATUS_ORIGINAL
Definition: type_var.h:49
@ SCIP_VARSTATUS_FIXED
Definition: type_var.h:52
@ SCIP_VARSTATUS_COLUMN
Definition: type_var.h:51
@ SCIP_VARSTATUS_MULTAGGR
Definition: type_var.h:54
@ SCIP_VARSTATUS_NEGATED
Definition: type_var.h:55
@ SCIP_VARSTATUS_AGGREGATED
Definition: type_var.h:53
@ SCIP_VARSTATUS_LOOSE
Definition: type_var.h:50