-
Notifications
You must be signed in to change notification settings - Fork 279
Expand file tree
/
Copy pathscip.pxi
More file actions
12596 lines (10114 loc) · 392 KB
/
scip.pxi
File metadata and controls
12596 lines (10114 loc) · 392 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
##@file scip.pxi
#@brief holding functions in python that reference the SCIP public functions included in scip.pxd
import weakref
from os.path import abspath
from os.path import splitext
import os
import sys
import warnings
import locale
cimport cython
from cpython cimport Py_INCREF, Py_DECREF
from cpython.pycapsule cimport PyCapsule_New, PyCapsule_IsValid, PyCapsule_GetPointer
from libc.stdlib cimport malloc, free
from libc.stdio cimport stdout, stderr, fdopen, fputs, fflush, fclose
from posix.stdio cimport fileno
from collections.abc import Iterable
from itertools import repeat
from dataclasses import dataclass
from typing import Union
import numpy as np
include "expr.pxi"
include "lp.pxi"
include "benders.pxi"
include "benderscut.pxi"
include "branchrule.pxi"
include "conshdlr.pxi"
include "cutsel.pxi"
include "event.pxi"
include "heuristic.pxi"
include "iisfinder.pxi"
include "presol.pxi"
include "pricer.pxi"
include "propagator.pxi"
include "sepa.pxi"
include "reader.pxi"
include "relax.pxi"
include "nodesel.pxi"
include "matrix.pxi"
# recommended SCIP version; major version is required
MAJOR = 10
MINOR = 0
PATCH = 0
# for external user functions use def; for functions used only inside the interface (starting with _) use cdef
# todo: check whether this is currently done like this
if sys.version_info >= (3, 0):
str_conversion = lambda x:bytes(x,'utf-8')
else:
str_conversion = lambda x:x
_SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=',
SCIP_BOUNDTYPE_LOWER: '>='}
cdef extern from "scip/config.h":
"""
#ifdef WITH_DEBUG_SOLUTION
#define PYSCIPOPT_WITH_DEBUG_SOLUTION 1
#else
#define PYSCIPOPT_WITH_DEBUG_SOLUTION 0
#endif
"""
bint PYSCIPOPT_WITH_DEBUG_SOLUTION
# Mapping the SCIP_RESULT enum to a python class
# This is required to return SCIP_RESULT in the python code
# In __init__.py this is imported as SCIP_RESULT to keep the
# original naming scheme using capital letters
cdef class PY_SCIP_RESULT:
DIDNOTRUN = SCIP_DIDNOTRUN
DELAYED = SCIP_DELAYED
DIDNOTFIND = SCIP_DIDNOTFIND
FEASIBLE = SCIP_FEASIBLE
INFEASIBLE = SCIP_INFEASIBLE
UNBOUNDED = SCIP_UNBOUNDED
CUTOFF = SCIP_CUTOFF
SEPARATED = SCIP_SEPARATED
NEWROUND = SCIP_NEWROUND
REDUCEDDOM = SCIP_REDUCEDDOM
CONSADDED = SCIP_CONSADDED
CONSCHANGED = SCIP_CONSCHANGED
BRANCHED = SCIP_BRANCHED
SOLVELP = SCIP_SOLVELP
FOUNDSOL = SCIP_FOUNDSOL
SUSPENDED = SCIP_SUSPENDED
SUCCESS = SCIP_SUCCESS
cdef class PY_SCIP_PARAMSETTING:
DEFAULT = SCIP_PARAMSETTING_DEFAULT
AGGRESSIVE = SCIP_PARAMSETTING_AGGRESSIVE
FAST = SCIP_PARAMSETTING_FAST
OFF = SCIP_PARAMSETTING_OFF
cdef class PY_SCIP_LPPARAM:
FROMSCRATCH = SCIP_LPPAR_FROMSCRATCH
FASTMIP = SCIP_LPPAR_FASTMIP
SCALING = SCIP_LPPAR_SCALING
PRESOLVING = SCIP_LPPAR_PRESOLVING
PRICING = SCIP_LPPAR_PRICING
LPINFO = SCIP_LPPAR_LPINFO
FEASTOL = SCIP_LPPAR_FEASTOL
DUALFEASTOL = SCIP_LPPAR_DUALFEASTOL
BARRIERCONVTOL = SCIP_LPPAR_BARRIERCONVTOL
OBJLIM = SCIP_LPPAR_OBJLIM
LPITLIM = SCIP_LPPAR_LPITLIM
LPTILIM = SCIP_LPPAR_LPTILIM
MARKOWITZ = SCIP_LPPAR_MARKOWITZ
ROWREPSWITCH = SCIP_LPPAR_ROWREPSWITCH
THREADS = SCIP_LPPAR_THREADS
CONDITIONLIMIT = SCIP_LPPAR_CONDITIONLIMIT
TIMING = SCIP_LPPAR_TIMING
RANDOMSEED = SCIP_LPPAR_RANDOMSEED
POLISHING = SCIP_LPPAR_POLISHING
REFACTOR = SCIP_LPPAR_REFACTOR
cdef class PY_SCIP_PARAMEMPHASIS:
DEFAULT = SCIP_PARAMEMPHASIS_DEFAULT
CPSOLVER = SCIP_PARAMEMPHASIS_CPSOLVER
EASYCIP = SCIP_PARAMEMPHASIS_EASYCIP
FEASIBILITY = SCIP_PARAMEMPHASIS_FEASIBILITY
HARDLP = SCIP_PARAMEMPHASIS_HARDLP
OPTIMALITY = SCIP_PARAMEMPHASIS_OPTIMALITY
COUNTER = SCIP_PARAMEMPHASIS_COUNTER
PHASEFEAS = SCIP_PARAMEMPHASIS_PHASEFEAS
PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
PHASEPROOF = SCIP_PARAMEMPHASIS_PHASEPROOF
NUMERICS = SCIP_PARAMEMPHASIS_NUMERICS
BENCHMARK = SCIP_PARAMEMPHASIS_BENCHMARK
cdef class PY_SCIP_STATUS:
UNKNOWN = SCIP_STATUS_UNKNOWN
USERINTERRUPT = SCIP_STATUS_USERINTERRUPT
NODELIMIT = SCIP_STATUS_NODELIMIT
TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
TIMELIMIT = SCIP_STATUS_TIMELIMIT
MEMLIMIT = SCIP_STATUS_MEMLIMIT
GAPLIMIT = SCIP_STATUS_GAPLIMIT
SOLLIMIT = SCIP_STATUS_SOLLIMIT
BESTSOLLIMIT = SCIP_STATUS_BESTSOLLIMIT
RESTARTLIMIT = SCIP_STATUS_RESTARTLIMIT
PRIMALLIMIT = SCIP_STATUS_PRIMALLIMIT
DUALLIMIT = SCIP_STATUS_DUALLIMIT
OPTIMAL = SCIP_STATUS_OPTIMAL
INFEASIBLE = SCIP_STATUS_INFEASIBLE
UNBOUNDED = SCIP_STATUS_UNBOUNDED
INFORUNBD = SCIP_STATUS_INFORUNBD
StageNames = {}
cdef class PY_SCIP_STAGE:
INIT = SCIP_STAGE_INIT
PROBLEM = SCIP_STAGE_PROBLEM
TRANSFORMING = SCIP_STAGE_TRANSFORMING
TRANSFORMED = SCIP_STAGE_TRANSFORMED
INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
PRESOLVING = SCIP_STAGE_PRESOLVING
EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
PRESOLVED = SCIP_STAGE_PRESOLVED
INITSOLVE = SCIP_STAGE_INITSOLVE
SOLVING = SCIP_STAGE_SOLVING
SOLVED = SCIP_STAGE_SOLVED
EXITSOLVE = SCIP_STAGE_EXITSOLVE
FREETRANS = SCIP_STAGE_FREETRANS
FREE = SCIP_STAGE_FREE
cdef class PY_SCIP_NODETYPE:
FOCUSNODE = SCIP_NODETYPE_FOCUSNODE
PROBINGNODE = SCIP_NODETYPE_PROBINGNODE
SIBLING = SCIP_NODETYPE_SIBLING
CHILD = SCIP_NODETYPE_CHILD
LEAF = SCIP_NODETYPE_LEAF
DEADEND = SCIP_NODETYPE_DEADEND
JUNCTION = SCIP_NODETYPE_JUNCTION
PSEUDOFORK = SCIP_NODETYPE_PSEUDOFORK
FORK = SCIP_NODETYPE_FORK
SUBROOT = SCIP_NODETYPE_SUBROOT
REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE
cdef class PY_SCIP_PROPTIMING:
BEFORELP = SCIP_PROPTIMING_BEFORELP
DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP
AFTERLPLOOP = SCIP_PROPTIMING_AFTERLPLOOP
AFTERLPNODE = SCIP_PROPTIMING_AFTERLPNODE
cdef class PY_SCIP_PRESOLTIMING:
NONE = SCIP_PRESOLTIMING_NONE
FAST = SCIP_PRESOLTIMING_FAST
MEDIUM = SCIP_PRESOLTIMING_MEDIUM
EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE
cdef class PY_SCIP_HEURTIMING:
BEFORENODE = SCIP_HEURTIMING_BEFORENODE
DURINGLPLOOP = SCIP_HEURTIMING_DURINGLPLOOP
AFTERLPLOOP = SCIP_HEURTIMING_AFTERLPLOOP
AFTERLPNODE = SCIP_HEURTIMING_AFTERLPNODE
AFTERPSEUDONODE = SCIP_HEURTIMING_AFTERPSEUDONODE
AFTERLPPLUNGE = SCIP_HEURTIMING_AFTERLPPLUNGE
AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
BEFOREPRESOL = SCIP_HEURTIMING_BEFOREPRESOL
DURINGPRESOLLOOP = SCIP_HEURTIMING_DURINGPRESOLLOOP
AFTERPROPLOOP = SCIP_HEURTIMING_AFTERPROPLOOP
EventNames = {}
cdef class PY_SCIP_EVENTTYPE:
DISABLED = SCIP_EVENTTYPE_DISABLED
VARADDED = SCIP_EVENTTYPE_VARADDED
VARDELETED = SCIP_EVENTTYPE_VARDELETED
VARFIXED = SCIP_EVENTTYPE_VARFIXED
VARUNLOCKED = SCIP_EVENTTYPE_VARUNLOCKED
OBJCHANGED = SCIP_EVENTTYPE_OBJCHANGED
GLBCHANGED = SCIP_EVENTTYPE_GLBCHANGED
GUBCHANGED = SCIP_EVENTTYPE_GUBCHANGED
LBTIGHTENED = SCIP_EVENTTYPE_LBTIGHTENED
LBRELAXED = SCIP_EVENTTYPE_LBRELAXED
UBTIGHTENED = SCIP_EVENTTYPE_UBTIGHTENED
UBRELAXED = SCIP_EVENTTYPE_UBRELAXED
GHOLEADDED = SCIP_EVENTTYPE_GHOLEADDED
GHOLEREMOVED = SCIP_EVENTTYPE_GHOLEREMOVED
LHOLEADDED = SCIP_EVENTTYPE_LHOLEADDED
LHOLEREMOVED = SCIP_EVENTTYPE_LHOLEREMOVED
IMPLADDED = SCIP_EVENTTYPE_IMPLADDED
PRESOLVEROUND = SCIP_EVENTTYPE_PRESOLVEROUND
NODEFOCUSED = SCIP_EVENTTYPE_NODEFOCUSED
NODEFEASIBLE = SCIP_EVENTTYPE_NODEFEASIBLE
NODEINFEASIBLE = SCIP_EVENTTYPE_NODEINFEASIBLE
NODEBRANCHED = SCIP_EVENTTYPE_NODEBRANCHED
NODEDELETE = SCIP_EVENTTYPE_NODEDELETE
DUALBOUNDIMPROVED = SCIP_EVENTTYPE_DUALBOUNDIMPROVED
FIRSTLPSOLVED = SCIP_EVENTTYPE_FIRSTLPSOLVED
LPSOLVED = SCIP_EVENTTYPE_LPSOLVED
LPEVENT = SCIP_EVENTTYPE_LPEVENT
POORSOLFOUND = SCIP_EVENTTYPE_POORSOLFOUND
BESTSOLFOUND = SCIP_EVENTTYPE_BESTSOLFOUND
ROWADDEDSEPA = SCIP_EVENTTYPE_ROWADDEDSEPA
ROWDELETEDSEPA = SCIP_EVENTTYPE_ROWDELETEDSEPA
ROWADDEDLP = SCIP_EVENTTYPE_ROWADDEDLP
ROWDELETEDLP = SCIP_EVENTTYPE_ROWDELETEDLP
ROWCOEFCHANGED = SCIP_EVENTTYPE_ROWCOEFCHANGED
ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
ROWSIDECHANGED = SCIP_EVENTTYPE_ROWSIDECHANGED
SYNC = SCIP_EVENTTYPE_SYNC
GBDCHANGED = SCIP_EVENTTYPE_GBDCHANGED
LBCHANGED = SCIP_EVENTTYPE_LBCHANGED
UBCHANGED = SCIP_EVENTTYPE_UBCHANGED
BOUNDTIGHTENED = SCIP_EVENTTYPE_BOUNDTIGHTENED
BOUNDRELAXED = SCIP_EVENTTYPE_BOUNDRELAXED
BOUNDCHANGED = SCIP_EVENTTYPE_BOUNDCHANGED
GHOLECHANGED = SCIP_EVENTTYPE_GHOLECHANGED
LHOLECHANGED = SCIP_EVENTTYPE_LHOLECHANGED
HOLECHANGED = SCIP_EVENTTYPE_HOLECHANGED
DOMCHANGED = SCIP_EVENTTYPE_DOMCHANGED
VARCHANGED = SCIP_EVENTTYPE_VARCHANGED
VAREVENT = SCIP_EVENTTYPE_VAREVENT
NODESOLVED = SCIP_EVENTTYPE_NODESOLVED
NODEEVENT = SCIP_EVENTTYPE_NODEEVENT
SOLFOUND = SCIP_EVENTTYPE_SOLFOUND
SOLEVENT = SCIP_EVENTTYPE_SOLEVENT
GAPUPDATED = SCIP_EVENTTYPE_GAPUPDATED
ROWCHANGED = SCIP_EVENTTYPE_ROWCHANGED
ROWEVENT = SCIP_EVENTTYPE_ROWEVENT
cdef class PY_SCIP_LOCKTYPE:
MODEL = SCIP_LOCKTYPE_MODEL
CONFLICT = SCIP_LOCKTYPE_CONFLICT
cdef class PY_SCIP_IMPLINTTYPE:
NONE = SCIP_IMPLINTTYPE_NONE
WEAK = SCIP_IMPLINTTYPE_WEAK
STRONG = SCIP_IMPLINTTYPE_STRONG
cdef class PY_SCIP_LPSOLSTAT:
NOTSOLVED = SCIP_LPSOLSTAT_NOTSOLVED
OPTIMAL = SCIP_LPSOLSTAT_OPTIMAL
INFEASIBLE = SCIP_LPSOLSTAT_INFEASIBLE
UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
OBJLIMIT = SCIP_LPSOLSTAT_OBJLIMIT
ITERLIMIT = SCIP_LPSOLSTAT_ITERLIMIT
TIMELIMIT = SCIP_LPSOLSTAT_TIMELIMIT
ERROR = SCIP_LPSOLSTAT_ERROR
cdef class PY_SCIP_BRANCHDIR:
DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS
UPWARDS = SCIP_BRANCHDIR_UPWARDS
FIXED = SCIP_BRANCHDIR_FIXED
AUTO = SCIP_BRANCHDIR_AUTO
cdef class PY_SCIP_BENDERSENFOTYPE:
LP = SCIP_BENDERSENFOTYPE_LP
RELAX = SCIP_BENDERSENFOTYPE_RELAX
PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO
CHECK = SCIP_BENDERSENFOTYPE_CHECK
cdef class PY_SCIP_ROWORIGINTYPE:
UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC
CONS = SCIP_ROWORIGINTYPE_CONS
SEPA = SCIP_ROWORIGINTYPE_SEPA
REOPT = SCIP_ROWORIGINTYPE_REOPT
cdef class PY_SCIP_SOLORIGIN:
ORIGINAL = SCIP_SOLORIGIN_ORIGINAL
ZERO = SCIP_SOLORIGIN_ZERO
LPSOL = SCIP_SOLORIGIN_LPSOL
NLPSOL = SCIP_SOLORIGIN_NLPSOL
RELAXSOL = SCIP_SOLORIGIN_RELAXSOL
PSEUDOSOL = SCIP_SOLORIGIN_PSEUDOSOL
PARTIAL = SCIP_SOLORIGIN_PARTIAL
UNKNOWN = SCIP_SOLORIGIN_UNKNOWN
def PY_SCIP_CALL(SCIP_RETCODE rc):
if rc == SCIP_OKAY:
pass
elif rc == SCIP_ERROR:
raise Exception('SCIP: unspecified error!')
elif rc == SCIP_NOMEMORY:
raise MemoryError('SCIP: insufficient memory error!')
elif rc == SCIP_READERROR:
raise IOError('SCIP: read error!')
elif rc == SCIP_WRITEERROR:
raise IOError('SCIP: write error!')
elif rc == SCIP_NOFILE:
raise IOError('SCIP: file not found error!')
elif rc == SCIP_FILECREATEERROR:
raise IOError('SCIP: cannot create file!')
elif rc == SCIP_LPERROR:
raise Exception('SCIP: error in LP solver!')
elif rc == SCIP_NOPROBLEM:
raise Exception('SCIP: no problem exists!')
elif rc == SCIP_INVALIDCALL:
raise Exception('SCIP: method cannot be called at this time'
+ ' in solution process!')
elif rc == SCIP_INVALIDDATA:
raise Exception('SCIP: error in input data!')
elif rc == SCIP_INVALIDRESULT:
raise Exception('SCIP: method returned an invalid result code!')
elif rc == SCIP_PLUGINNOTFOUND:
raise Exception('SCIP: a required plugin was not found !')
elif rc == SCIP_PARAMETERUNKNOWN:
raise KeyError('SCIP: the parameter with the given name was not found!')
elif rc == SCIP_PARAMETERWRONGTYPE:
raise LookupError('SCIP: the parameter is not of the expected type!')
elif rc == SCIP_PARAMETERWRONGVAL:
raise ValueError('SCIP: the value is invalid for the given parameter!')
elif rc == SCIP_KEYALREADYEXISTING:
raise KeyError('SCIP: the given key is already existing in table!')
elif rc == SCIP_MAXDEPTHLEVEL:
raise Exception('SCIP: maximal branching depth level exceeded!')
else:
raise Exception('SCIP: unknown return code!')
cdef class Event:
"""Base class holding a pointer to corresponding SCIP_EVENT."""
@staticmethod
cdef create(SCIP_EVENT* scip_event):
"""
Main method for creating an Event class. Is used instead of __init__.
Parameters
----------
scip_event : SCIP_EVENT*
A pointer to the SCIP_EVENT
Returns
-------
event : Event
The Python representative of the SCIP_EVENT
"""
if scip_event == NULL:
raise Warning("cannot create Event with SCIP_EVENT* == NULL")
event = Event()
event.event = scip_event
return event
def getType(self):
"""
Gets type of event.
Returns
-------
PY_SCIP_EVENTTYPE
"""
return SCIPeventGetType(self.event)
def getName(self):
"""
Gets name of event.
Returns
-------
str
"""
if not EventNames:
self._getEventNames()
return EventNames[self.getType()]
def _getEventNames(self):
"""Gets event names."""
for name in dir(PY_SCIP_EVENTTYPE):
attr = getattr(PY_SCIP_EVENTTYPE, name)
if isinstance(attr, int):
EventNames[attr] = name
def __repr__(self):
return str(self.getType())
def __str__(self):
return self.getName()
def getNewBound(self):
"""
Gets new bound for a bound change event.
Returns
-------
float
"""
return SCIPeventGetNewbound(self.event)
def getOldBound(self):
"""
Gets old bound for a bound change event.
Returns
-------
float
"""
return SCIPeventGetOldbound(self.event)
def getVar(self):
"""
Gets variable for a variable event (var added, var deleted, var fixed,
objective value or domain change, domain hole added or removed).
Returns
-------
Variable
"""
cdef SCIP_VAR* var = SCIPeventGetVar(self.event)
return Variable.create(var)
def getNode(self):
"""
Gets node for a node or LP event.
Returns
-------
Node
"""
cdef SCIP_NODE* node = SCIPeventGetNode(self.event)
return Node.create(node)
def getRow(self):
"""
Gets row for a row event.
Returns
-------
Row
"""
cdef SCIP_ROW* row = SCIPeventGetRow(self.event)
return Row.create(row)
def __hash__(self):
return hash(<size_t>self.event)
def __eq__(self, other):
return (self.__class__ == other.__class__
and self.event == (<Event>other).event)
cdef class Column:
"""Base class holding a pointer to corresponding SCIP_COL."""
@staticmethod
cdef create(SCIP_COL* scipcol):
"""
Main method for creating a Column class. Is used instead of __init__.
Parameters
----------
scipcol : SCIP_COL*
A pointer to the SCIP_COL
Returns
-------
col : Column
The Python representative of the SCIP_COL
"""
if scipcol == NULL:
raise Warning("cannot create Column with SCIP_COL* == NULL")
col = Column()
col.scip_col = scipcol
return col
def getLPPos(self):
"""
Gets position of column in current LP, or -1 if it is not in LP.
Returns
-------
int
"""
return SCIPcolGetLPPos(self.scip_col)
def getBasisStatus(self):
"""
Gets the basis status of a column in the LP solution
Returns
-------
str
Possible values are "lower", "basic", "upper", and "zero"
Raises
------
Exception
If SCIP returns an unknown basis status
Notes
-----
Returns basis status "zero" for columns not in the current SCIP LP.
"""
cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col)
if stat == SCIP_BASESTAT_LOWER:
return "lower"
elif stat == SCIP_BASESTAT_BASIC:
return "basic"
elif stat == SCIP_BASESTAT_UPPER:
return "upper"
elif stat == SCIP_BASESTAT_ZERO:
return "zero"
else:
raise Exception('SCIP returned unknown base status!')
def isIntegral(self):
"""
Returns whether the associated variable is of integral type (binary, integer, implicit integer).
Returns
-------
bool
"""
return SCIPcolIsIntegral(self.scip_col)
def getVar(self):
"""
Gets variable this column represents.
Returns
-------
Variable
"""
cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col)
return Variable.create(var)
def getPrimsol(self):
"""
Gets the primal LP solution of a column.
Returns
-------
float
"""
return SCIPcolGetPrimsol(self.scip_col)
def getLb(self):
"""
Gets lower bound of column.
Returns
-------
float
"""
return SCIPcolGetLb(self.scip_col)
def getUb(self):
"""
Gets upper bound of column.
Returns
-------
float
"""
return SCIPcolGetUb(self.scip_col)
def getObjCoeff(self):
"""
Gets objective value coefficient of a column.
Returns
-------
float
"""
return SCIPcolGetObj(self.scip_col)
def getAge(self):
"""
Gets the age of the column, i.e., the total number of successive times a column was in the LP
and was 0.0 in the solution.
Returns
-------
int
"""
return SCIPcolGetAge(self.scip_col)
def __hash__(self):
return hash(<size_t>self.scip_col)
def __eq__(self, other):
return (self.__class__ == other.__class__
and self.scip_col == (<Column>other).scip_col)
cdef class ColumnExact:
"""Base class holding a pointer to corresponding SCIP_COLEXACT."""
@staticmethod
cdef create(SCIP_COLEXACT* scipcolexact):
"""
Main method for creating a ColumnExact class. Is used instead of __init__.
Parameters
----------
scipcolexact : SCIP_COLEXACT*
A pointer to the SCIP_COLEXACT
Returns
-------
col : ColumnExact
The Python representative of the SCIP_COLEXACT
"""
if scipcolexact == NULL:
raise Warning("cannot create ColumnExact with SCIP_COLEXACT* == NULL")
col = ColumnExact()
col.scip_col_exact = scipcolexact
return col
cdef class Row:
"""Base class holding a pointer to corresponding SCIP_ROW."""
@staticmethod
cdef create(SCIP_ROW* sciprow):
"""
Main method for creating a Row class. Is used instead of __init__.
Parameters
----------
sciprow : SCIP_ROW*
A pointer to the SCIP_ROW
Returns
-------
row : Row
The Python representative of the SCIP_ROW
"""
if sciprow == NULL:
raise Warning("cannot create Row with SCIP_ROW* == NULL")
row = Row()
row.scip_row = sciprow
return row
property name:
def __get__(self):
cname = bytes( SCIProwGetName(self.scip_row) )
return cname.decode('utf-8')
def getLhs(self):
"""
Returns the left hand side of row.
Returns
-------
float
"""
return SCIProwGetLhs(self.scip_row)
def getRhs(self):
"""
Returns the right hand side of row.
Returns
-------
float
"""
return SCIProwGetRhs(self.scip_row)
def getConstant(self):
"""
Gets constant shift of row.
Returns
-------
float
"""
return SCIProwGetConstant(self.scip_row)
def getDualsol(self):
"""
Returns the dual solution of row.
Returns
-------
float
"""
return SCIProwGetDualsol(self.scip_row)
def getDualfarkas(self):
"""
Returns the dual Farkas solution of row.
Returns
-------
float
"""
return SCIProwGetDualfarkas(self.scip_row)
def getLPPos(self):
"""
Gets position of row in current LP, or -1 if it is not in LP.
Returns
-------
int
"""
return SCIProwGetLPPos(self.scip_row)
def getBasisStatus(self):
"""
Gets the basis status of a row in the LP solution.
Returns
-------
str
Possible values are "lower", "basic", and "upper"
Raises
------
Exception
If SCIP returns an unknown or "zero" basis status
Notes
-----
Returns basis status "basic" for rows not in the current SCIP LP.
"""
cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row)
if stat == SCIP_BASESTAT_LOWER:
return "lower"
elif stat == SCIP_BASESTAT_BASIC:
return "basic"
elif stat == SCIP_BASESTAT_UPPER:
return "upper"
elif stat == SCIP_BASESTAT_ZERO:
# this shouldn't happen!
raise Exception('SCIP returned base status zero for a row!')
else:
raise Exception('SCIP returned unknown base status!')
def isIntegral(self):
"""
Returns TRUE iff the activity of the row (without the row's constant)
is always integral in a feasible solution.
Returns
-------
bool
"""
return SCIProwIsIntegral(self.scip_row)
def isLocal(self):
"""
Returns TRUE iff the row is only valid locally.
Returns
-------
bool
"""
return SCIProwIsLocal(self.scip_row)
def isModifiable(self):
"""
Returns TRUE iff row is modifiable during node processing (subject to column generation).
Returns
-------
bool
"""
return SCIProwIsModifiable(self.scip_row)
def isRemovable(self):
"""
Returns TRUE iff row is removable from the LP (due to aging or cleanup).
Returns
-------
bool
"""
return SCIProwIsRemovable(self.scip_row)
def isInGlobalCutpool(self):
"""
Return TRUE iff row is a member of the global cut pool.
Returns
-------
bool
"""
return SCIProwIsInGlobalCutpool(self.scip_row)
def getOrigintype(self):
"""
Returns type of origin that created the row.
Returns
-------
PY_SCIP_ROWORIGINTYPE
"""
return SCIProwGetOrigintype(self.scip_row)
def getConsOriginConshdlrtype(self):
"""
Returns type of constraint handler that created the row.
Returns
-------
str
"""
cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row)
return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8')
def getNNonz(self):
"""
Get number of nonzero entries in row vector.
Returns
-------
int
"""
return SCIProwGetNNonz(self.scip_row)
def getNLPNonz(self):
"""
Get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP.
Returns
-------
int
"""
return SCIProwGetNLPNonz(self.scip_row)
def getCols(self):
"""
Gets list with columns of nonzero entries
Returns
-------
list of Column
"""
cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row)
cdef int i
return [Column.create(cols[i]) for i in range(self.getNNonz())]
def getVals(self):
"""
Gets list with coefficients of nonzero entries.
Returns
-------
list of int
"""
cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row)
cdef int i
return [vals[i] for i in range(self.getNNonz())]
def getAge(self):
"""
Gets the age of the row. (The consecutive times the row has been non-active in the LP).
Returns
-------
int
"""
return SCIProwGetAge(self.scip_row)
def getNorm(self):
"""
Gets Euclidean norm of row vector.
Returns
-------
float
"""
return SCIProwGetNorm(self.scip_row)
def __hash__(self):
return hash(<size_t>self.scip_row)
def __eq__(self, other):
return (self.__class__ == other.__class__
and self.scip_row == (<Row>other).scip_row)
cdef class RowExact:
"""Base class holding a pointer to corresponding SCIP_ROW."""
@staticmethod
cdef create(SCIP_ROWEXACT* sciprowexact):
"""
Main method for creating a RowExact class. Is used instead of __init__.
Parameters
----------
sciprow : SCIP_ROWEXACT*
A pointer to the SCIP_ROWEXACT
Returns
-------
row : Row
The Python representative of the SCIP_ROWEXACT
"""
if sciprowexact == NULL:
raise Warning("cannot create Row with SCIP_ROWEXACT* == NULL")
row_exact = RowExact()
row_exact.scip_row_exact = sciprowexact
return row_exact
cdef class NLRow:
"""Base class holding a pointer to corresponding SCIP_NLROW."""
@staticmethod
cdef create(SCIP_NLROW* scipnlrow):
"""
Main method for creating a NLRow class. Is used instead of __init__.
Parameters
----------
scipnlrow : SCIP_NLROW*
A pointer to the SCIP_NLROW
Returns
-------
nlrow : NLRow
The Python representative of the SCIP_NLROW
"""
if scipnlrow == NULL:
raise Warning("cannot create NLRow with SCIP_NLROW* == NULL")
nlrow = NLRow()
nlrow.scip_nlrow = scipnlrow
return nlrow
property name:
def __get__(self):
cname = bytes( SCIPnlrowGetName(self.scip_nlrow) )
return cname.decode('utf-8')