···

       
8
       
8
       
 
       
  - sh download.sh vendor master vendor:${MZNARCH} vendor.zip

     

       
9
       
9
       
 
       
  - unzip -q vendor.zip

     

       
10
       
10
       
 
       


     

       
11
       
11
       
-
       
.download_vendor_win: &download_vendor_win

     

       
11
       
11
       
+
       
.download_vendor: &download_vendor_win

     

       
12
       
12
       
 
       
  - curl -o download.sh --location --header "PRIVATE-TOKEN:%ACCESS_TOKEN%" --silent https://gitlab.com/api/v4/snippets/1796163/raw

     

       
13
       
13
       
 
       
  - dos2unix download.sh

     

       
14
       
14
       
 
       
  - sh download.sh vendor master vendor:%MZNARCH% vendor.zip

     
···

       
19
       
19
       
 
       
  - sh download.sh vendor master bundle:${MZNARCH} vendor.zip

     

       
20
       
20
       
 
       
  - unzip -q vendor.zip

     

       
21
       
21
       
 
       


     

       
22
       
22
       
-
       
.download_bundle_win: &download_bundle_win

     

       
22
       
22
       
+
       
.download_bundle: &download_bundle_win

     

       
23
       
23
       
 
       
  - curl -o download.sh --location --header "PRIVATE-TOKEN:%ACCESS_TOKEN%" --silent https://gitlab.com/api/v4/snippets/1796163/raw

     

       
24
       
24
       
 
       
  - dos2unix download.sh

     

       
25
       
25
       
 
       
  - sh download.sh vendor master bundle:%MZNARCH% vendor.zip

     
···

       
51
       
51
       
 
       


     

       
52
       
52
       
 
       
build:linux:

     

       
53
       
53
       
 
       
  extends: .build

     

       
54
       
54
       
-
       
  image: minizinc/build-environment:cpp

     

       
54
       
54
       
+
       
  image: dekker1/minibuild:cpp

     

       
55
       
55
       
 
       
  variables:

     

       
56
       
56
       
 
       
    MZNARCH: "linux"

     

       
57
       
57
       
 
       
    CMAKE_ARCH: "Ninja"

     
···

       
59
       
59
       
 
       


     

       
60
       
60
       
 
       
build:musl:

     

       
61
       
61
       
 
       
  extends: .build

     

       
62
       
62
       
-
       
  image: minizinc/build-environment:alpine

     

       
62
       
62
       
+
       
  image: dekker1/minibuild:alpine

     

       
63
       
63
       
 
       
  variables:

     

       
64
       
64
       
 
       
    MZNARCH: "musl"

     

       
65
       
65
       
 
       
    CMAKE_ARCH: "Ninja"

     
···

       
118
       
118
       
 
       


     

       
119
       
119
       
 
       
test:format:

     

       
120
       
120
       
 
       
  stage: test

     

       
121
       
121
       
-
       
  image: minizinc/build-environment:clang-format

     

       
121
       
121
       
+
       
  image: dekker1/minibuild:clang-format

     

       
122
       
122
       
 
       
  script:

     

       
123
       
123
       
 
       
    - cmake -S . -B build -GNinja -DCLANG_FORMAT_EXECUTABLE="run-clang-format" -DCLANG_FORMAT_FLAGS="--color always"

     

       
124
       
124
       
 
       
    - cmake --build build --target format

     
···

       
134
       
134
       
 
       
test:analyse:

     

       
135
       
135
       
 
       
  extends: .build

     

       
136
       
136
       
 
       
  stage: test

     

       
137
       
137
       
-
       
  image: minizinc/build-environment:clang-tidy

     

       
137
       
137
       
+
       
  image: dekker1/minibuild:clang-tidy

     

       
138
       
138
       
 
       
  variables:

     

       
139
       
139
       
 
       
    MZNARCH: "linux"

     

       
140
       
140
       
 
       
    CMAKE_ARCH: "Ninja"

     
···

       
158
       
158
       
 
       
  before_script:

     

       
159
       
159
       
 
       
    - *download_bundle

     

       
160
       
160
       
 
       
    # TODO: Add gecode configuration to the Gecode solver

     

       
161
       
161
       
-
       
    - 'echo ''{"id":"org.gecode.gecode","name":"Gecode","description":"Gecode FlatZinc executable","version":"6.1.1","mznlib":"share/gecode/mznlib","executable":"bin/fzn-gecode","tags":["cp","int","float","set","restart"],"stdFlags":["-a","-f","-n","-p","-r","-s","-t"],"extraFlags":[["-c-d","Recomputation commit distance","int","8"],["-a-d","Recomputation adaption distance","int","2"],["-decay","Decay factor","float","0.99"],["-node","Node cutoff","int","0"],["-fail","Failure cutoff","int","0"],["-restart","Restart sequence type","opt:none:constant:linear:luby:geometric","none"],["-restart-base","Base for geometric restart sequence","float","1.5"],["-restart-scale","Scale factor for restart sequence","int","250"],["-nogoods","Use no-goods from restarts","bool","false"],["-nogoods-limit","Depth limit for no-good extraction","int","128"]],"supportsMzn":false,"supportsFzn":true,"needsSolns2Out":true,"needsMznExecutable":false,"needsStdlibDir":false,"isGUIApplication":false}'' > vendor/gecode/gecode.msc'

     

       
161
       
161
       
+
       
    - "echo '{\"id\":\"org.gecode.gecode\",\"name\":\"Gecode\",\"description\":\"Gecode FlatZinc executable\",\"version\":\"6.1.1\",\"mznlib\":\"share/gecode/mznlib\",\"executable\":\"bin/fzn-gecode\",\"tags\":[\"cp\",\"int\",\"float\",\"set\",\"restart\"],\"stdFlags\":[\"-a\",\"-f\",\"-n\",\"-p\",\"-r\",\"-s\",\"-t\"],\"extraFlags\":[[\"-c-d\",\"Recomputation commit distance\",\"int\",\"8\"],[\"-a-d\",\"Recomputation adaption distance\",\"int\",\"2\"],[\"-decay\",\"Decay factor\",\"float\",\"0.99\"],[\"-node\",\"Node cutoff\",\"int\",\"0\"],[\"-fail\",\"Failure cutoff\",\"int\",\"0\"],[\"-restart\",\"Restart sequence type\",\"opt:none:constant:linear:luby:geometric\",\"none\"],[\"-restart-base\",\"Base for geometric restart sequence\",\"float\",\"1.5\"],[\"-restart-scale\",\"Scale factor for restart sequence\",\"int\",\"250\"],[\"-nogoods\",\"Use no-goods from restarts\",\"bool\",\"false\"],[\"-nogoods-limit\",\"Depth limit for no-good extraction\",\"int\",\"128\"]],\"supportsMzn\":false,\"supportsFzn\":true,\"needsSolns2Out\":true,\"needsMznExecutable\":false,\"needsStdlibDir\":false,\"isGUIApplication\":false}' > vendor/gecode/gecode.msc"

     

       
162
       
162
       
 
       
    - export PATH=$CI_PROJECT_DIR/minizinc/bin:$PATH

     

       
163
       
163
       
 
       
    - minizinc --solvers

     

       
164
       
164
       
 
       
    - cd tests

     
···

       
170
       
170
       
 
       
  artifacts:

     

       
171
       
171
       
 
       
    when: always

     

       
172
       
172
       
 
       
    paths:

     

       
173
       
173
       
-
       
      - tests/output

     

       
173
       
173
       
+
       
    - tests/output

     

       
174
       
174
       
 
       
    reports:

     

       
175
       
175
       
 
       
      junit: tests/output/junit*.xml

     

       
176
       
176
       
 
       
  cache:

     
···

       
213
       
213
       
 
       
    - call env\Scripts\activate.bat

     

       
214
       
214
       
 
       
    - pip install -r requirements.txt

     

       
215
       
215
       
 
       
  after_script:

     

       
216
       
216
       
-
       
    - "echo Test results at https://minizinc.gitlab.io/-/minizinc/-/jobs/%CI_JOB_ID%/artifacts/tests/output/report.html"

     

       
216
       
216
       
+
       
    - 'echo Test results at https://minizinc.gitlab.io/-/minizinc/-/jobs/%CI_JOB_ID%/artifacts/tests/output/report.html'

     

       
217
       
217
       
 
       
  tags: [win64]

     

       
218
       
218
       
 
       
  dependencies: ["build:win64"]

     

       
219
       
219
       
 
       
  needs: ["build:win64"]

     

···

       
5
       
5
       
 
       
#  -- Project information and versioning.

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
project(libminizinc

     

       
8
       
8
       
-
       
        VERSION 2.5.5

     

       
8
       
8
       
+
       
        VERSION 2.5.4

     

       
9
       
9
       
 
       
        LANGUAGES CXX C)

     

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
if(NOT BUILD_REF)

     

···

       
4
       
4
       
 
       
For detailed bug reports consult the issue tracker at

     

       
5
       
5
       
 
       
https://github.com/MiniZinc/libminizinc/issues.

     

       
6
       
6
       
 
       


     

       
7
       
7
       
-
       
.. _v2.5.5:

     

       
8
       
8
       
-
       


     

       
9
       
9
       
-
       
`Version 2.5.5 <https://github.com/MiniZinc/MiniZincIDE/releases/tag/2.5.5>`__

     

       
10
       
10
       
-
       
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

     

       
11
       
11
       
-
       


     

       
12
       
12
       
-
       
(released 19 March 2021)

     

       
13
       
13
       
-
       


     

       
14
       
14
       
-
       
Changes:

     

       
15
       
15
       
-
       
^^^^^^^^

     

       
16
       
16
       
-
       


     

       
17
       
17
       
-
       
-  Make min/max on an array of optional variables return a non-optional var,

     

       
18
       
18
       
-
       
   behaving as if absent values are not in the array.

     

       
19
       
19
       
-
       


     

       
20
       
20
       
-
       
Bug fixes:

     

       
21
       
21
       
-
       
^^^^^^^^^^

     

       
22
       
22
       
-
       


     

       
23
       
23
       
-
       
-  Insert par array literals in the common subexpression elimination map, fixing

     

       
24
       
24
       
-
       
   a FlatZinc code bloat issue (:bugref:`458`).

     

       
25
       
25
       
-
       


     

       
26
       
26
       
-
       
Changes in the IDE:

     

       
27
       
27
       
-
       
^^^^^^^^^^^^^^^^^^^

     

       
28
       
28
       
-
       


     

       
29
       
29
       
-
       
-  Fix editing of custom string parameters so they don't get converted to

     

       
30
       
30
       
-
       
   floats.

     

       
31
       
31
       
-
       
-  Fix crash on Windows caused when the ``PATH`` environment contains unicode

     

       
32
       
32
       
-
       
   characters.

     

       
33
       
33
       
-
       


     

       
34
       
34
       
-
       
.. _v2.5.4:

     

       
35
       
35
       
-
       


     

       
36
       
36
       
-
       
`Version 2.5.4 <https://github.com/MiniZinc/MiniZincIDE/releases/tag/2.5.4>`__

     

       
37
       
37
       
-
       
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

     

       
38
       
38
       
-
       


     

       
39
       
39
       
-
       
(released 16 March 2021)

     

       
40
       
40
       
-
       


     

       
41
       
41
       
-
       
Changes:

     

       
42
       
42
       
-
       
^^^^^^^^

     

       
43
       
43
       
-
       


     

       
44
       
44
       
-
       
-  Allow empty arrays in global cardinality constraints (:bugref:`440`).

     

       
45
       
45
       
-
       
-  Add piecewise_linear for non-continuous intervals.

     

       
46
       
46
       
-
       
-  Fail on empty variable domains in agenda.

     

       
47
       
47
       
-
       
-  Allow coercion of JSON lists to enum definitions (:bugref:`441`).

     

       
48
       
48
       
-
       
-  Update strictly_decreasing with documentation and opt version (:bugref:`454`).

     

       
49
       
49
       
-
       
-  Remove MIP-specific ``fzn_less(eq)_bool(_reif).mzn``.

     

       
50
       
50
       
-
       
-  Add ``mzn_in_symmetry_breaking_constraint()`` for internal use.

     

       
51
       
51
       
-
       
-  Add MIP decompositions for ``lex_less[eq]_*``.

     

       
52
       
52
       
-
       
-  Add ``lex_chain_*`` globals, and use them in ``lex2[_strict]``.

     

       
53
       
53
       
-
       
-  Improve detection of variable declarations which are actually par to allow

     

       
54
       
54
       
-
       
   more use of overloaded par versions of predicates.

     

       
55
       
55
       
-
       
-  Update documentation on installation of OR-Tools.

     

       
56
       
56
       
-
       
-  Report CPU time in ``solveTime`` statistic for MIP solvers.

     

       
57
       
57
       
-
       


     

       
58
       
58
       
-
       
Bug fixes:

     

       
59
       
59
       
-
       
^^^^^^^^^^

     

       
60
       
60
       
-
       


     

       
61
       
61
       
-
       
-  Fix handling of bad Xpress licenses when collecting extra flags.

     

       
62
       
62
       
-
       
-  Don't propagate annotations into annotation calls to infinite recursion.

     

       
63
       
63
       
-
       
-  Add missing par opt versions of coercion functions.

     

       
64
       
64
       
-
       
-  Revert incorrect renaming of ``has_output_item`` to ``has_outputItem`` in

     

       
65
       
65
       
-
       
   model interface output.

     

       
66
       
66
       
-
       
-  Fix incorrect grammar specification in documentation (:bugref:`453`).

     

       
67
       
67
       
-
       
-  Fix crash when defining enums with no members (:bugref:`443`, :bugref:`444`).

     

       
68
       
68
       
-
       
-  Support undefined enums in the type checker.

     

       
69
       
69
       
-
       
-  Fix CPLEX solver ID in documentation.

     

       
70
       
70
       
-
       
-  Never insert par expressions in the common subexpression elimination map.

     

       
71
       
71
       
-
       
-  Fix cv flag propagation when the body of a let or function is cv.

     

       
72
       
72
       
-
       
-  Fix equality test for annotations involving indirection.

     

       
73
       
73
       
-
       
-  Don't modify the infinite domain of optional variables (:bugref:`456`).

     

       
74
       
74
       
-
       
-  Don't immediately evaluate output_only arrays when generating dzn output.

     

       
75
       
75
       
-
       
-  Coerce boolean objectives to integers.

     

       
76
       
76
       
-
       
-  Don't create copies of global declarations when creating par versions of

     

       
77
       
77
       
-
       
   functions.

     

       
78
       
78
       
-
       
-  Compile infinite domains with holes into constraints (:bugref:`457`).

     

       
79
       
79
       
-
       
-  Use generic flattening inside generators, disallowing free boolean variables

     

       
80
       
80
       
-
       
   inside ``in`` expressions (:bugref:`451`).

     

       
81
       
81
       
-
       
-  Strip library paths from includes in multi-pass compilation (:bugref:`455`).

     

       
82
       
82
       
-
       
-  Canonicalise file names of includes to ensure the same file is not included

     

       
83
       
83
       
-
       
   multiple times.

     

       
84
       
84
       
-
       
-  Escape paths in printed ``include`` items, fixing backslash problems on

     

       
85
       
85
       
-
       
   Windows.

     

       
86
       
86
       
-
       
-  Follow ids to declarations when flattening par arrays (:bugref:`448`).

     

       
87
       
87
       
-
       
-  Ignore par constants during chain compression.

     

       
88
       
88
       
-
       
-  Fix flattening of all-par set literals.

     

       
89
       
89
       
-
       


     

       
90
       
90
       
-
       
Changes in the IDE:

     

       
91
       
91
       
-
       
^^^^^^^^^^^^^^^^^^^

     

       
92
       
92
       
-
       


     

       
93
       
93
       
-
       
-  Fix possible crash due to incorrect use of WriteFile on Windows.

     

       
94
       
94
       
-
       
-  Ensure Gecode Gist dependencies are present in the Linux bundle and AppImage

     

       
95
       
95
       
-
       
   (:idebugref:`132`).

     

       
96
       
96
       
-
       
-  Fix crash when stopping solver during exit.

     

       
97
       
97
       
-
       
-  Don't show irrelevant context menu entries in the project explorer.

     

       
98
       
98
       
-
       
-  Add support for HTTP/S links in the output pane.

     

       
99
       
99
       
-
       
-  Fix crash when saving CP Profiler executions where there is no info

     

       
100
       
100
       
-
       
   associated with a node.

     

       
101
       
101
       
-
       
-  Show a warning when there are open files which are not part of a MOOC

     

       
102
       
102
       
-
       
   submission.

     

       
103
       
103
       
-
       
-  Fix double spinbox precision issues (:idebugref:`134`).

     

       
104
       
104
       
-
       
-  Include Gecode Gist and CP Profiler dependencies in Snap package.

     

       
105
       
105
       
-
       
-  Allow opening of multiple files through the open file menu option.

     

       
106
       
106
       
-
       
-  Ensure file dialogs save last path when opening files.

     

       
107
       
107
       
-
       
-  Make the escape key close the find/replace dialog when focussed on any child

     

       
108
       
108
       
-
       
   widget.

     

       
109
       
109
       
-
       
-  Allow setting MOOC submission items as mandatory.

     

       
110
       
110
       
-
       


     

       
111
       
7
       
 
       
.. _v2.5.3:

     

       
112
       
8
       
 
       


     

       
113
       
9
       
 
       
`Version 2.5.3 <https://github.com/MiniZinc/MiniZincIDE/releases/tag/2.5.3>`__

     

···

       
61
       
61
       
 
       
  FOUND_VAR CPLEX_FOUND

     

       
62
       
62
       
 
       
  REQUIRED_VARS CPLEX_INCLUDE CPLEX_LIBRARY

     

       
63
       
63
       
 
       
  VERSION_VAR CPLEX_VERSION

     

       
64
       
64
       
-
       
  FAIL_MESSAGE "Could NOT find CPlex, use CPlex_ROOT to hint its location"

     

       
64
       
64
       
+
       
  FAIL_MESSAGE "Could NOT find CPlex, use CPLEX_ROOT to hint its location"

     

       
65
       
65
       
 
       
)

     

       
66
       
66
       
 
       


     

       
67
       
67
       
 
       
if(CPLEX_PLUGIN AND HAS_WINDOWS_H AND NOT HAS_DLFCN_H)

     

···

       
69
       
69
       
 
       
  FOUND_VAR GUROBI_FOUND

     

       
70
       
70
       
 
       
  REQUIRED_VARS GUROBI_INCLUDE GUROBI_LIBRARY

     

       
71
       
71
       
 
       
  VERSION_VAR GUROBI_VERSION

     

       
72
       
72
       
-
       
  FAIL_MESSAGE "Could NOT find Gurobi, use Gurobi_ROOT to hint its location"

     

       
72
       
72
       
+
       
  FAIL_MESSAGE "Could NOT find Gurobi, use GUROBI_ROOT to hint its location"

     

       
73
       
73
       
 
       
)

     

       
74
       
74
       
 
       


     

       
75
       
75
       
 
       
if(GUROBI_PLUGIN AND HAS_WINDOWS_H AND NOT HAS_DLFCN_H)

     

···

       
13
       
13
       
 
       
  )

     

       
14
       
14
       
 
       
  target_include_directories(minizinc_osicbc PRIVATE ${OSICBC_INCLUDE_DIRS})

     

       
15
       
15
       
 
       
  add_dependencies(minizinc_osicbc minizinc_mip)

     

       
16
       
16
       
-
       
  if (UNIX AND NOT WIN32)

     

       
17
       
17
       
-
       
    target_compile_definitions(minizinc_osicbc PRIVATE HAVE_CONFIG_H)

     

       
18
       
18
       
-
       
  endif()

     

       
19
       
16
       
 
       


     

       
20
       
17
       
 
       
  ### Setup correct compilation into the MiniZinc library

     

       
21
       
18
       
 
       
  target_compile_definitions(mzn PRIVATE HAS_OSICBC)

     

···

       
73
       
73
       
 
       
# The short X.Y version.

     

       
74
       
74
       
 
       
version = '2.5'

     

       
75
       
75
       
 
       
# The full version, including alpha/beta/rc tags.

     

       
76
       
76
       
-
       
release = '2.5.5'

     

       
76
       
76
       
+
       
release = '2.5.4'

     

       
77
       
77
       
 
       


     

       
78
       
78
       
 
       
# The language for content autogenerated by Sphinx. Refer to documentation

     

       
79
       
79
       
 
       
# for a list of supported languages.

     

···

       
511
       
511
       
 
       


     

       
512
       
512
       
 
       
  {

     

       
513
       
513
       
 
       
    "mzn_solver_path": ["/usr/share/choco"],

     

       
514
       
514
       
-
       
    "tagDefaults": [["cp","org.choco-solver.choco"],["mip","org.minizinc.mip.cplex"],["","org.gecode.gecode"]],

     

       
515
       
515
       
-
       
    "solverDefaults": [["org.minizinc.mip.cplex","--cplex-dll","/opt/CPLEX_Studio128/cplex/bin/x86-64_sles10_4.1/libcplex128.so"]] 

     

       
514
       
514
       
+
       
    "tagDefaults": [["cp","org.choco-solver.choco"],["mip","org.minizinc.cplex"],["","org.gecode.gecode"]],

     

       
515
       
515
       
+
       
    "solverDefaults": [["org.minizinc.cplex","--cplex-dll","/opt/CPLEX_Studio128/cplex/bin/x86-64_sles10_4.1/libcplex128.so"]] 

     

       
516
       
516
       
 
       
  }

     

       
517
       
517
       
 
       


     

       
518
       
518
       
 
       
Configuration values in the user-specific configuration file override the global values, except for solver default arguments, which are only overridden if the name of the option is the same, and otherwise get added to the command line.

     

···

       
73
       
73
       
 
       
# The short X.Y version.

     

       
74
       
74
       
 
       
version = '2.5'

     

       
75
       
75
       
 
       
# The full version, including alpha/beta/rc tags.

     

       
76
       
76
       
-
       
release = '2.5.5'

     

       
76
       
76
       
+
       
release = '2.5.4'

     

       
77
       
77
       
 
       


     

       
78
       
78
       
 
       
# The language for content autogenerated by Sphinx. Refer to documentation

     

       
79
       
79
       
 
       
# for a list of supported languages.

     

···

       
35
       
35
       
 
       
<assign-item> ::= <ident> "=" <expr>

     

       
36
       
36
       
 
       


     

       
37
       
37
       
 
       
% Constraint items

     

       
38
       
38
       
-
       
<constraint-item> ::= "constraint" [ <string-annotation> ] <expr>

     

       
38
       
38
       
+
       
<constraint-item> ::= "constraint" <string-annotation> <expr>

     

       
39
       
39
       
 
       


     

       
40
       
40
       
 
       
% Solve item

     

       
41
       
41
       
 
       
<solve-item> ::= "solve" <annotations> "satisfy"

     
···

       
80
       
80
       
 
       
                      | <base-type>

     

       
81
       
81
       
 
       
                      | <ti-variable-expr-tail>

     

       
82
       
82
       
 
       
                      | "ann"

     

       
83
       
83
       
-
       
                      | "{" <expr> "," ... "}"

     

       
83
       
83
       
+
       
                      | { <expr> "," ... }

     

       
84
       
84
       
 
       
                      | <num-expr> ".." <num-expr>

     

       
85
       
85
       
 
       


     

       
86
       
86
       
 
       
% Type-inst variables

     

···

       
86
       
86
       
 
       


     

       
87
       
87
       
 
       
You can install the OR-Tools FlatZinc module as binary or obtain the source code from GitHub (https://github.com/google/or-tools).

     

       
88
       
88
       
 
       
You can find detailed compilation instructions for OR-Tools on https://developers.google.com/optimization/.

     

       
89
       
89
       
-
       
Since version 8, `cmake` is supported, see the instructions. Previously, to compile the FlatZinc module from source,

     

       
90
       
90
       
-
       
run the following in a terminal (from within the OR-Tools source code directory):

     

       
89
       
89
       
+
       
To compile the FlatZinc module from source, run the following in a terminal (from within the OR-Tools source code directory):

     

       
91
       
90
       
 
       


     

       
92
       
91
       
 
       
.. code-block:: bash

     

       
93
       
92
       
 
       


     

       
94
       
93
       
 
       
  make fz -j8

     

       
95
       
94
       
 
       
  make test_fz

     

       
96
       
95
       
 
       


     

       
97
       
97
       
-
       
Since version 8, `cmake --build . --target install` puts a solver configuration file in `/usr/share/minizinc`, so the MiniZinc finds

     

       
98
       
98
       
-
       
OR-Tools automatically. With earlier versions, in order to use OR-Tools with MiniZinc, you have to create an appropriate solver configuration file.

     

       
96
       
96
       
+
       
In order to use OR-Tools with MiniZinc, you have to create an appropriate solver configuration file.

     

       
99
       
97
       
 
       
Add a file ``ortools.msc`` in an appropriate location (see :ref:`sec-cmdline-conffiles`) containing the following,

     

       
100
       
98
       
 
       
where you replace ``<INSTALLATION_PREFIX>`` with the actual installation path and update the version number if necessary:

     

       
101
       
99
       
 
       


     

···

       
143
       
143
       
 
       
  -DfIndConstr=true -DfMIPdomains=false        %% Use solver's indicator constraints, see below

     

       
144
       
144
       
 
       
  -DMinMaxGeneral=true                         %% Send min/max constraints to the solver (Gurobi only)

     

       
145
       
145
       
 
       
  -DQuadrFloat=false -DQuadrInt=false          %% Not forward float/integer multiplications for MIQCP backends, see below

     

       
146
       
146
       
-
       
  -DUseCumulative=false                        %% Not forward cumulative with fixed durations/resources (SCIP only)

     

       
147
       
147
       
-
       
  -DUseOrbisack=false                          %% Not forward lex_lesseq for binary/bool vectors (SCIP only)

     

       
148
       
148
       
-
       
  -DOrbisackAlwaysModelConstraint=true         %% lex_lesseq ignores being in symmetry_breaking_constraint() (SCIP only)

     

       
149
       
149
       
-
       
                                               %% Required for SCIP 7.0.2, or use patch: http://listserv.zib.de/pipermail/scip/2021-February/004213.html

     

       
150
       
150
       
-
       
  -DUseOrbitope=false                          %% Not forward lex_chain_lesseq for binary/bool matrices (SCIP only)

     

       
146
       
146
       
+
       
  -DCumulative=false                           %% Not forward cumulative with fixed durations/resources (SCIP only)

     

       
151
       
147
       
 
       
  --no-half-reifications                       %% Turn off halfreification (full reification was until v2.2.3)

     

       
152
       
148
       
 
       


     

       
153
       
149
       
 
       
Some Solver Options and Changed Default Values

     

···

       
22
       
22
       
 
       
#define _CRT_SECURE_NO_WARNINGS

     

       
23
       
23
       
 
       
#endif

     

       
24
       
24
       
 
       


     

       
25
       
25
       
-
       
#define MZN_MIPD_assert_soft(c, e)                                                         \

     

       
25
       
25
       
+
       
#define MZN_MIPD__assert_soft(c, e)                                                        \

     

       
26
       
26
       
 
       
  do {                                                                                     \

     

       
27
       
27
       
 
       
    static int nn = 0;                                                                     \

     

       
28
       
28
       
 
       
    if (!(c))                                                                              \

     

       
29
       
29
       
 
       
      if (++nn <= 1) std::cerr << e << std::endl; /* NOLINT(bugprone-macro-parentheses) */ \

     

       
30
       
30
       
 
       
  } while (0)

     

       
31
       
31
       
-
       
#define MZN_MIPD_assert_hard(c) MZN_ASSERT_HARD(c)

     

       
32
       
32
       
-
       
#define MZN_MIPD_assert_hard_msg(c, e) MZN_ASSERT_HARD_MSG(c, e)

     

       
33
       
33
       
-
       
#define MZN_MIPD_FLATTENING_ERROR_IF_NOT(cond, envi, loc, msg) \

     

       
34
       
34
       
-
       
  do {                                                         \

     

       
35
       
35
       
-
       
    if (!(cond)) {                                             \

     

       
36
       
36
       
-
       
      std::ostringstream oss;                                  \

     

       
37
       
37
       
-
       
      oss << msg; /* NOLINT(bugprone-macro-parentheses) */     \

     

       
38
       
38
       
-
       
      throw FlatteningError(envi, loc, oss.str());             \

     

       
39
       
39
       
-
       
    }                                                          \

     

       
31
       
31
       
+
       
#define MZN_MIPD__assert_hard(c) MZN_ASSERT_HARD(c)

     

       
32
       
32
       
+
       
#define MZN_MIPD__assert_hard_msg(c, e) MZN_ASSERT_HARD_MSG(c, e)

     

       
33
       
33
       
+
       
#define MZN_MIPD__FLATTENING_ERROR__IF_NOT(cond, envi, loc, msg) \

     

       
34
       
34
       
+
       
  do {                                                           \

     

       
35
       
35
       
+
       
    if (!(cond)) {                                               \

     

       
36
       
36
       
+
       
      std::ostringstream oss;                                    \

     

       
37
       
37
       
+
       
      oss << msg; /* NOLINT(bugprone-macro-parentheses) */       \

     

       
38
       
38
       
+
       
      throw FlatteningError(envi, loc, oss.str());               \

     

       
39
       
39
       
+
       
    }                                                            \

     

       
40
       
40
       
 
       
  } while (0)

     

       
41
       
41
       
-
       
#define MZN_MIPD_ASSERT_FOR_SAT(cond, envi, loc, msg)                             \

     

       
41
       
41
       
+
       
#define MZN_MIPD__ASSERT_FOR_SAT(cond, envi, loc, msg)                            \

     

       
42
       
42
       
 
       
  do {                                                                            \

     

       
43
       
43
       
 
       
    if (!(cond)) {                                                                \

     

       
44
       
44
       
 
       
      std::ostringstream oss;                                                     \

     

···

       
1838
       
1838
       
 
       
    ASTString set_card;          // NOLINT(readability-identifier-naming)

     

       
1839
       
1839
       
 
       
    ASTString pow;

     

       
1840
       
1840
       
 
       


     

       
1841
       
1841
       
-
       
    ASTString mzn_set_in_internal;  // NOLINT(readability-identifier-naming)

     

       
1842
       
1842
       
-
       


     

       
1843
       
1841
       
 
       
    ASTString introduced_var;  // NOLINT(readability-identifier-naming)

     

       
1844
       
1842
       
 
       
    ASTString anonEnumFromStrings;

     

       
1845
       
1843
       
 
       
  } ids;

     

···

       
87
       
87
       
 
       
public:

     

       
88
       
88
       
 
       
  /// Evaluate bool expression that may contain variables

     

       
89
       
89
       
 
       
  static bool evalBoolCV(EnvI& env, Expression* e);

     

       
90
       
90
       
-
       
  /// Flatten expression that may contain variables

     

       
91
       
91
       
-
       
  static KeepAlive flattenCV(EnvI& env, Expression* e);

     

       
92
       
90
       
 
       
};

     

       
93
       
91
       
 
       


     

       
94
       
92
       
 
       
template <class Eval>

     
···

       
124
       
122
       
 
       
          KeepAlive nextin;

     

       
125
       
123
       
 
       
          Expression* gen_in = e->in(gen + 1);

     

       
126
       
124
       
 
       
          if (gen_in->type().isvar() || gen_in->type().cv()) {

     

       
127
       
127
       
-
       
            gen_in = eval.flattenCV(env, e->in(gen + 1))();

     

       
125
       
125
       
+
       
            gen_in = eval.flatten(env, e->in(gen + 1));

     

       
128
       
126
       
 
       
          }

     

       
129
       
127
       
 
       
          if (gen_in->type().dim() == 0) {

     

       
130
       
128
       
 
       
            GCLock lock;

     
···

       
156
       
154
       
 
       
  CallStackItem csi(env, e->decl(gen, id)->id(), i);

     

       
157
       
155
       
 
       
  if (in() == nullptr) {

     

       
158
       
156
       
 
       
    // this is an assignment generator

     

       
159
       
159
       
-
       
    Expression* asn;

     

       
160
       
160
       
-
       
    if (e->where(gen)->type().isvar() || e->where(gen)->type().cv()) {

     

       
161
       
161
       
-
       
      asn = eval.flattenCV(env, e->where(gen))();

     

       
162
       
162
       
-
       
    } else {

     

       
163
       
163
       
-
       
      asn = eval_par(env, e->where(gen));

     

       
164
       
164
       
-
       
    }

     

       
157
       
157
       
+
       
    Expression* asn = e->where(gen)->type().isPar() ? eval_par(env, e->where(gen))

     

       
158
       
158
       
+
       
                                                    : eval.flatten(env, e->where(gen));

     

       
165
       
159
       
 
       
    e->decl(gen, id)->e(asn);

     

       
166
       
160
       
 
       
    e->rehash();

     

       
167
       
161
       
 
       
  } else {

     
···

       
184
       
178
       
 
       
          KeepAlive nextin;

     

       
185
       
179
       
 
       
          Expression* gen_in = e->in(gen + 1);

     

       
186
       
180
       
 
       
          if (gen_in->type().isvar() || gen_in->type().cv()) {

     

       
187
       
187
       
-
       
            gen_in = eval.flattenCV(env, e->in(gen + 1))();

     

       
181
       
181
       
+
       
            gen_in = eval.flatten(env, e->in(gen + 1));

     

       
188
       
182
       
 
       
          }

     

       
189
       
183
       
 
       
          if (gen_in->type().dim() == 0) {

     

       
190
       
184
       
 
       
            GCLock lock;

     
···

       
269
       
263
       
 
       
          in = new SetLit(Location(), eval_intset(env, e->in(0)));

     

       
270
       
264
       
 
       
        }

     

       
271
       
265
       
 
       
      } else {

     

       
272
       
272
       
-
       
        if (e->in(0)->type().isvar() || e->in(0)->type().cv()) {

     

       
273
       
273
       
-
       
          in = eval_array_lit(env, eval.flattenCV(env, e->in(0))());

     

       
266
       
266
       
+
       
        if (e->in(0)->type().isvar()) {

     

       
267
       
267
       
+
       
          in = eval_array_lit(env, eval.flatten(env, e->in(0)));

     

       
274
       
268
       
 
       
        } else {

     

       
275
       
269
       
 
       
          in = eval_array_lit(env, e->in(0));

     

       
276
       
270
       
 
       
        }

     

···

       
109
       
109
       
 
       
  std::vector<int> modifiedVarDecls;

     

       
110
       
110
       
 
       
  std::unordered_set<std::string> deprecationWarnings;

     

       
111
       
111
       
 
       
  int inRedundantConstraint;

     

       
112
       
112
       
-
       
  int inSymmetryBreakingConstraint;

     

       
113
       
112
       
 
       
  int inMaybePartial;

     

       
114
       
113
       
 
       
  struct {

     

       
115
       
114
       
 
       
    int reifConstraints;

     

···

       
36
       
36
       
 
       
/// Remove all links to variables in flat model from output model in \a env

     

       
37
       
37
       
 
       
void cleanup_output(EnvI& env);

     

       
38
       
38
       
 
       


     

       
39
       
39
       
-
       
ArrayLit* create_json_output(EnvI& env, bool outputObjective, bool includeOutputItem,

     

       
40
       
40
       
-
       
                             bool hasChecker);

     

       
39
       
39
       
+
       
ArrayLit* create__json_output(EnvI& env, bool outputObjective, bool includeOutputItem,

     

       
40
       
40
       
+
       
                              bool hasChecker);

     

       
41
       
41
       
 
       


     

       
42
       
42
       
 
       
}  // namespace MiniZinc

     

···

       
9
       
9
       
 
       
 * License, v. 2.0. If a copy of the MPL was not distributed with this

     

       
10
       
10
       
 
       
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     

       
11
       
11
       
 
       


     

       
12
       
12
       
-
       
#pragma once

     

       
12
       
12
       
+
       
#ifndef __MINIZINC_PARAM_CONFIG_HH__

     

       
13
       
13
       
+
       
#define __MINIZINC_PARAM_CONFIG_HH__

     

       
13
       
14
       
 
       


     

       
14
       
15
       
 
       
#include <minizinc/ast.hh>

     

       
15
       
16
       
 
       
#include <minizinc/solver_config.hh>

     
···

       
56
       
57
       
 
       
  const char* what() const throw() override { return "MiniZinc: solver parameter error"; }

     

       
57
       
58
       
 
       
};

     

       
58
       
59
       
 
       
}  // namespace MiniZinc

     

       
60
       
60
       
+
       


     

       
61
       
61
       
+
       
#endif

     

···

       
75
       
75
       
 
       
class ParserState {

     

       
76
       
76
       
 
       
public:

     

       
77
       
77
       
 
       
  ParserState(const std::string& f, const std::string& b, std::ostream& err0,

     

       
78
       
78
       
-
       
              const std::vector<std::string>& includePaths0, std::vector<ParseWorkItem>& files0,

     

       
79
       
79
       
-
       
              std::map<std::string, Model*>& seenModels0, MiniZinc::Model* model0, bool isDatafile0,

     

       
80
       
80
       
-
       
              bool isFlatZinc0, bool isSTDLib0, bool parseDocComments0)

     

       
78
       
78
       
+
       
              std::vector<ParseWorkItem>& files0, std::map<std::string, Model*>& seenModels0,

     

       
79
       
79
       
+
       
              MiniZinc::Model* model0, bool isDatafile0, bool isFlatZinc0, bool isSTDLib0,

     

       
80
       
80
       
+
       
              bool parseDocComments0)

     

       
81
       
81
       
 
       
      : filename(f.c_str()),

     

       
82
       
82
       
 
       
        buf(b.c_str()),

     

       
83
       
83
       
 
       
        pos(0),

     
···

       
85
       
85
       
 
       
        lineStartPos(0),

     

       
86
       
86
       
 
       
        nTokenNextStart(1),

     

       
87
       
87
       
 
       
        hadNewline(false),

     

       
88
       
88
       
-
       
        includePaths(includePaths0),

     

       
89
       
88
       
 
       
        files(files0),

     

       
90
       
89
       
 
       
        seenModels(seenModels0),

     

       
91
       
90
       
 
       
        model(model0),

     
···

       
106
       
105
       
 
       
  int nTokenNextStart;

     

       
107
       
106
       
 
       
  bool hadNewline;

     

       
108
       
107
       
 
       


     

       
109
       
109
       
-
       
  const std::vector<std::string>& includePaths;

     

       
110
       
108
       
 
       
  std::vector<ParseWorkItem>& files;

     

       
111
       
109
       
 
       
  std::map<std::string, Model*>& seenModels;

     

       
112
       
110
       
 
       
  MiniZinc::Model* model;

     
···

       
150
       
148
       
 
       
    pos += num;

     

       
151
       
149
       
 
       
    return num;

     

       
152
       
150
       
 
       
  }

     

       
153
       
153
       
-
       


     

       
154
       
154
       
-
       
  std::string canonicalFilename(const std::string& f) const;

     

       
155
       
151
       
 
       
};

     

       
156
       
152
       
 
       


     

       
157
       
153
       
 
       
Model* parse(Env& env, const std::vector<std::string>& filename,

     

···

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
#include <minizinc/solver.hh>

     

       
15
       
15
       
 
       


     

       
16
       
16
       
+
       
const auto SolverInstance__ERROR = MiniZinc::SolverInstance::ERROR;  // before windows.h

     

       
16
       
17
       
 
       
#ifdef _WIN32

     

       
17
       
18
       
 
       
#define NOMINMAX

     

       
18
       
19
       
 
       
#include <Windows.h>

     

···

       
76
       
76
       
 
       
    const char* const searchCompleteMsgDef = "==========";

     

       
77
       
77
       
 
       
    /// Output values

     

       
78
       
78
       
 
       
    std::string solutionSeparator = solutionSeparatorDef;

     

       
79
       
79
       
-
       
    std::string solutionComma;

     

       
79
       
79
       
+
       
    std::string solutionComma = "";

     

       
80
       
80
       
 
       
    std::string unsatisfiableMsg = unsatisfiableMsgDef;

     

       
81
       
81
       
 
       
    std::string unboundedMsg = unboundedMsgDef;

     

       
82
       
82
       
 
       
    std::string unsatorunbndMsg = unsatorunbndMsgDef;

     

···

       
33
       
33
       
 
       
  enum StatusReason { SR_OK = -5, SR_TIME, SR_MEMORY, SR_LIMIT, SR_ERROR };

     

       
34
       
34
       
 
       
};

     

       
35
       
35
       
 
       


     

       
36
       
36
       
-
       
const SolverInstance::Status SolverInstanceError = SolverInstance::ERROR;  // just in case...

     

       
36
       
36
       
+
       
const SolverInstance::Status SolverInstance__ERROR = SolverInstance::ERROR;  // just in case...

     

       
37
       
37
       
 
       


     

       
38
       
38
       
 
       
}  // namespace MiniZinc

     

···

       
21
       
21
       
 
       
#include <scip/scipdefplugins.h>

     

       
22
       
22
       
 
       


     

       
23
       
23
       
 
       
#ifndef _WIN32

     

       
24
       
24
       
-
       
// NOLINTNEXTLINE(bugprone-reserved-identifier)

     

       
25
       
24
       
 
       
#define __stdcall

     

       
26
       
25
       
 
       
#endif

     

       
27
       
26
       
 
       


     
···

       
106
       
105
       
 
       
  SCIP_RETCODE(__stdcall* SCIPcreateConsBasicCumulative)

     

       
107
       
106
       
 
       
  (SCIP* scip, SCIP_CONS** cons, const char* name, int nvars, SCIP_VAR** vars, int* durations,

     

       
108
       
107
       
 
       
   int* demands, int capacity);

     

       
109
       
109
       
-
       


     

       
110
       
110
       
-
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
111
       
111
       
-
       
  SCIP_RETCODE(__stdcall* SCIPcreateConsBasicOrbisack)

     

       
112
       
112
       
-
       
  (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP_VAR** vars1, SCIP_VAR** vars2, int nrows,

     

       
113
       
113
       
-
       
   SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons);

     

       
114
       
114
       
-
       


     

       
115
       
115
       
-
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
116
       
116
       
-
       
  SCIP_RETCODE(__stdcall* SCIPcreateConsBasicOrbitope)

     

       
117
       
117
       
-
       
  (SCIP* scip,                     /**< SCIP data structure */

     

       
118
       
118
       
-
       
   SCIP_CONS** cons,               /**< pointer to hold the created constraint */

     

       
119
       
119
       
-
       
   const char* name,               /**< name of constraint */

     

       
120
       
120
       
-
       
   SCIP_VAR*** vars,               /**< matrix of variables on which the symmetry acts */

     

       
121
       
121
       
-
       
   SCIP_ORBITOPETYPE orbitopetype, /**< type of orbitope constraint */

     

       
122
       
122
       
-
       
   int nspcons,                    /**< number of set partitioning/packing constraints  <=> p */

     

       
123
       
123
       
-
       
   int nblocks,                    /**< number of symmetric variable blocks             <=> q */

     

       
124
       
124
       
-
       
   SCIP_Bool resolveprop,          /**< should propagation be resolved? */

     

       
125
       
125
       
-
       
   SCIP_Bool ismodelcons           /**< whether the orbitope is a model constraint */

     

       
126
       
126
       
-
       
  );

     

       
127
       
127
       
-
       


     

       
128
       
108
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
129
       
109
       
 
       
  SCIP_Longint(__stdcall* SCIPgetNSolsFound)(SCIP* scip);

     

       
130
       
110
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     
···

       
378
       
358
       
 
       
  /// Cumulative, currently SCIP only

     

       
379
       
359
       
 
       
  void addCumulative(int nnz, int* rmatind, double* d, double* r, double b,

     

       
380
       
360
       
 
       
                     const std::string& rowName = "") override;

     

       
381
       
381
       
-
       


     

       
382
       
382
       
-
       
  /// Lex-lesseq binary, currently SCIP only

     

       
383
       
383
       
-
       
  void addLexLesseq(int nnz, int* rmatind1, int* rmatind2, bool isModelCons,

     

       
384
       
384
       
-
       
                    const std::string& rowName = "") override;

     

       
385
       
385
       
-
       


     

       
386
       
386
       
-
       
  void addLexChainLesseq(int m, int n, int* rmatind, int nOrbitopeType, bool resolveprop,

     

       
387
       
387
       
-
       
                         bool isModelCons, const std::string& rowName = "") override;

     

       
388
       
361
       
 
       


     

       
389
       
362
       
 
       
  /// Times constraint: var[x]*var[y] == var[z]

     

       
390
       
363
       
 
       
  void addTimes(int x, int y, int z, const std::string& rowName = "") override;

     

···

       
544
       
544
       
 
       
    };

     

       
545
       
545
       
 
       
    env.outstream.setf(std::ios::fixed);

     

       
546
       
546
       
 
       
    env.outstream.precision(4);

     

       
547
       
547
       
-
       
    env.outstream << "%%%mzn-stat: solveTime=" << _mipWrapper->getCPUTime() << std::endl;

     

       
547
       
547
       
+
       
    env.outstream << "%%%mzn-stat: solveTime=" << _mipWrapper->getWallTimeElapsed() << std::endl;

     

       
548
       
548
       
 
       
    ;

     

       
549
       
549
       
 
       
    env.outstream.copyfmt(oldState);

     

       
550
       
550
       
 
       


     
···

       
979
       
979
       
 
       
void p_cumulative(SolverInstanceBase& si, const Call* call) {

     

       
980
       
980
       
 
       
  auto& gi = dynamic_cast<MIPSolverinstance<MIPWrapper>&>(si);

     

       
981
       
981
       
 
       


     

       
982
       
982
       
+
       
  std::unique_ptr<SECCutGen> pCG(new SECCutGen(gi.getMIPWrapper()));

     

       
983
       
983
       
+
       


     

       
982
       
984
       
 
       
  assert(call->argCount() == 4);

     

       
983
       
985
       
 
       


     

       
984
       
986
       
 
       
  std::vector<MIPSolver::Variable> startTimes;

     
···

       
992
       
994
       
 
       
  gi.getMIPWrapper()->addCumulative(

     

       
993
       
995
       
 
       
      startTimes.size(), startTimes.data(), durations.data(), demands.data(), b,

     

       
994
       
996
       
 
       
      make_constraint_name("p_cumulative_", (gi.getMIPWrapper()->nAddedRows++), call));

     

       
995
       
995
       
-
       
}

     

       
996
       
996
       
-
       


     

       
997
       
997
       
-
       
template <class MIPWrapper>

     

       
998
       
998
       
-
       
void p_lex_lesseq_binary(SolverInstanceBase& si, const Call* call) {

     

       
999
       
999
       
-
       
  auto& gi = dynamic_cast<MIPSolverinstance<MIPWrapper>&>(si);

     

       
1000
       
1000
       
-
       


     

       
1001
       
1001
       
-
       
  assert(call->argCount() == 3);

     

       
1002
       
1002
       
-
       


     

       
1003
       
1003
       
-
       
  std::vector<MIPSolver::Variable> vec1;

     

       
1004
       
1004
       
-
       
  std::vector<MIPSolver::Variable> vec2;

     

       
1005
       
1005
       
-
       
  gi.exprToVarArray(call->arg(0), vec1);

     

       
1006
       
1006
       
-
       
  gi.exprToVarArray(call->arg(1), vec2);

     

       
1007
       
1007
       
-
       
  auto isModelCons = gi.exprToConst(call->arg(2));

     

       
1008
       
1008
       
-
       
  MZN_ASSERT_HARD(vec1.size() == vec2.size());

     

       
1009
       
1009
       
-
       


     

       
1010
       
1010
       
-
       
  gi.getMIPWrapper()->addLexLesseq(

     

       
1011
       
1011
       
-
       
      vec1.size(), vec1.data(), vec2.data(), (bool)isModelCons,

     

       
1012
       
1012
       
-
       
      make_constraint_name("p_lex_lesseq__orbisack_", (gi.getMIPWrapper()->nAddedRows++), call));

     

       
1013
       
1013
       
-
       
}

     

       
1014
       
1014
       
-
       


     

       
1015
       
1015
       
-
       
template <class MIPWrapper>

     

       
1016
       
1016
       
-
       
void p_lex_chain_lesseq_binary(SolverInstanceBase& si, const Call* call) {

     

       
1017
       
1017
       
-
       
  auto& gi = dynamic_cast<MIPSolverinstance<MIPWrapper>&>(si);

     

       
1018
       
1018
       
-
       


     

       
1019
       
1019
       
-
       
  assert(call->argCount() == 5);

     

       
1020
       
1020
       
-
       


     

       
1021
       
1021
       
-
       
  std::vector<MIPSolver::Variable> vars;

     

       
1022
       
1022
       
-
       
  gi.exprToVarArray(call->arg(0), vars);

     

       
1023
       
1023
       
-
       
  auto m = gi.exprToConst(call->arg(1));

     

       
1024
       
1024
       
-
       
  auto orbitopeType = gi.exprToConst(call->arg(2));

     

       
1025
       
1025
       
-
       
  auto resolveprop = gi.exprToConst(call->arg(3));

     

       
1026
       
1026
       
-
       
  auto isModelCons = gi.exprToConst(call->arg(4));

     

       
1027
       
1027
       
-
       


     

       
1028
       
1028
       
-
       
  gi.getMIPWrapper()->addLexChainLesseq(

     

       
1029
       
1029
       
-
       
      m, vars.size() / m, vars.data(), orbitopeType, (bool)resolveprop, (bool)isModelCons,

     

       
1030
       
1030
       
-
       
      make_constraint_name("p_lex_lesseq__orbisack_", (gi.getMIPWrapper()->nAddedRows++), call));

     

       
1031
       
997
       
 
       
}

     

       
1032
       
998
       
 
       


     

       
1033
       
999
       
 
       
/// The XBZ cut generator

     
···

       
1152
       
1118
       
 
       
                          SCIPConstraints::p_indicator_eq_if1<MIPWrapper>);

     

       
1153
       
1119
       
 
       


     

       
1154
       
1120
       
 
       
  _constraintRegistry.add("fzn_cumulative_fixed_d_r", SCIPConstraints::p_cumulative<MIPWrapper>);

     

       
1155
       
1155
       
-
       


     

       
1156
       
1156
       
-
       
  _constraintRegistry.add("fzn_lex_lesseq__orbisack",

     

       
1157
       
1157
       
-
       
                          SCIPConstraints::p_lex_lesseq_binary<MIPWrapper>);

     

       
1158
       
1158
       
-
       


     

       
1159
       
1159
       
-
       
  _constraintRegistry.add("fzn_lex_chain_lesseq__orbitope",

     

       
1160
       
1160
       
-
       
                          SCIPConstraints::p_lex_chain_lesseq_binary<MIPWrapper>);

     

       
1161
       
1121
       
 
       


     

       
1162
       
1122
       
 
       
  _constraintRegistry.add("bounds_disj", SCIPConstraints::p_bounds_disj<MIPWrapper>);

     

       
1163
       
1123
       
 
       


     

···

       
54
       
54
       
 
       
  /// Lazy cut. Can cut off otherwise feasible integer solutions.

     

       
55
       
55
       
 
       
  /// Callback should be able to produce previously generated cuts again if needed [Gurobi]

     

       
56
       
56
       
 
       
  static const int MaskConsType_Lazy = 4;

     

       
57
       
57
       
-
       
  enum Status { OPT, SAT, UNSAT, UNBND, UNSATorUNBND, UNKNOWN, ERROR_STATUS };

     

       
57
       
57
       
+
       
  enum Status { OPT, SAT, UNSAT, UNBND, UNSATorUNBND, UNKNOWN, __ERROR };

     

       
58
       
58
       
 
       


     

       
59
       
59
       
 
       
  /// Search strategy for the solver

     

       
60
       
60
       
 
       
  enum SearchType { FIXED_SEARCH = 0, FREE_SEARCH = 1, UNIFORM_SEARCH = 2 };

     
···

       
102
       
102
       
 
       
    LinConType sense = LQ;

     

       
103
       
103
       
 
       
    double rhs = 0.0;

     

       
104
       
104
       
 
       
    int mask = 0;  // need to know what type of cuts are registered before solve()  TODO

     

       
105
       
105
       
-
       
    std::string rowName;

     

       
105
       
105
       
+
       
    std::string rowName = "";

     

       
106
       
106
       
 
       
    void addVar(int i, double c) {

     

       
107
       
107
       
 
       
      rmatind.push_back(i);

     

       
108
       
108
       
 
       
      rmatval.push_back(c);

     
···

       
282
       
282
       
 
       
                             const std::string& rowName = "") {

     

       
283
       
283
       
 
       
    throw std::runtime_error("Cumulative constraints not supported. ");

     

       
284
       
284
       
 
       
  }

     

       
285
       
285
       
-
       


     

       
286
       
286
       
-
       
  /// Lex-lesseq binary, currently SCIP only

     

       
287
       
287
       
-
       
  virtual void addLexLesseq(int nnz, int* rmatind1, int* rmatind2, bool isModelCons,

     

       
288
       
288
       
-
       
                            const std::string& rowName = "") {

     

       
289
       
289
       
-
       
    throw std::runtime_error("MIP: lex_lesseq built-in not supported. ");

     

       
290
       
290
       
-
       
  }

     

       
291
       
291
       
-
       


     

       
292
       
292
       
-
       
  /// Lex-chain-lesseq binary, currently SCIP only

     

       
293
       
293
       
-
       
  virtual void addLexChainLesseq(int m, int n, int* rmatind, int nOrbitopeType, bool resolveprop,

     

       
294
       
294
       
-
       
                                 bool isModelCons, const std::string& rowName = "") {

     

       
295
       
295
       
-
       
    throw std::runtime_error("MIP: lex_chain_lesseq built-in not supported. ");

     

       
296
       
296
       
-
       
  }

     

       
297
       
297
       
-
       


     

       
298
       
285
       
 
       
  /// 0: model-defined level, 1: free, 2: uniform search

     

       
299
       
286
       
 
       
  virtual int getFreeSearch() { return SearchType::FREE_SEARCH; }

     

       
300
       
287
       
 
       
  /// Return 0 if ignoring searches

     

···

       
38
       
38
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
39
       
39
       
 
       
  int(XPRS_CC* XPRSsetlogfile)(XPRSprob prob, const char* logname);

     

       
40
       
40
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
41
       
41
       
-
       
  int(XPRS_CC* XPRSsetintcontrol)(XPRSprob prob, int index, int ivalue);

     

       
41
       
41
       
+
       
  int(XPRS_CC* XPRSsetintcontrol)(XPRSprob prob, int _index, int _ivalue);

     

       
42
       
42
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
43
       
43
       
-
       
  int(XPRS_CC* XPRSsetdblcontrol)(XPRSprob prob, int index, double dvalue);

     

       
43
       
43
       
+
       
  int(XPRS_CC* XPRSsetdblcontrol)(XPRSprob prob, int _index, double _dvalue);

     

       
44
       
44
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
45
       
45
       
 
       
  double(XB_CC* XPRBgetsol)(struct Xbvar* var);

     

       
46
       
46
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
47
       
47
       
-
       
  int(XPRS_CC* XPRSgetintattrib)(XPRSprob prob, int index, int* ivalue);

     

       
47
       
47
       
+
       
  int(XPRS_CC* XPRSgetintattrib)(XPRSprob prob, int _index, int* _ivalue);

     

       
48
       
48
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
49
       
49
       
-
       
  int(XPRS_CC* XPRSgetdblattrib)(XPRSprob prob, int index, double* dvalue);

     

       
49
       
49
       
+
       
  int(XPRS_CC* XPRSgetdblattrib)(XPRSprob prob, int _index, double* _dvalue);

     

       
50
       
50
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
51
       
51
       
 
       
  int(XB_CC* XPRBbegincb)(struct Xbprob* prob, struct xo_prob_struct* optprob);

     

       
52
       
52
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     
···

       
95
       
95
       
 
       
  int(XPRS_CC* XPRSgetcontrolinfo)(XPRSprob prob, const char* sCaName, int* iHeaderId,

     

       
96
       
96
       
 
       
                                   int* iTypeinfo);

     

       
97
       
97
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
98
       
98
       
-
       
  int(XPRS_CC* XPRSgetintcontrol)(XPRSprob prob, int index, int* ivalue);

     

       
98
       
98
       
+
       
  int(XPRS_CC* XPRSgetintcontrol)(XPRSprob prob, int _index, int* _ivalue);

     

       
99
       
99
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
100
       
100
       
-
       
  int(XPRS_CC* XPRSgetintcontrol64)(XPRSprob prob, int index, XPRSint64* ivalue);

     

       
100
       
100
       
+
       
  int(XPRS_CC* XPRSgetintcontrol64)(XPRSprob prob, int _index, XPRSint64* _ivalue);

     

       
101
       
101
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
102
       
102
       
-
       
  int(XPRS_CC* XPRSgetdblcontrol)(XPRSprob prob, int index, double* dvalue);

     

       
102
       
102
       
+
       
  int(XPRS_CC* XPRSgetdblcontrol)(XPRSprob prob, int _index, double* _dvalue);

     

       
103
       
103
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
104
       
104
       
-
       
  int(XPRS_CC* XPRSgetstrcontrol)(XPRSprob prob, int index, char* svalue);

     

       
104
       
104
       
+
       
  int(XPRS_CC* XPRSgetstrcontrol)(XPRSprob prob, int _index, char* _svalue);

     

       
105
       
105
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
106
       
106
       
-
       
  int(XPRS_CC* XPRSsetintcontrol64)(XPRSprob prob, int index, XPRSint64 ivalue);

     

       
106
       
106
       
+
       
  int(XPRS_CC* XPRSsetintcontrol64)(XPRSprob prob, int _index, XPRSint64 _ivalue);

     

       
107
       
107
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
108
       
108
       
-
       
  int(XPRS_CC* XPRSgetstringcontrol)(XPRSprob prob, int index, char* svalue, int svaluesize,

     

       
109
       
109
       
-
       
                                     int* controlsize);

     

       
108
       
108
       
+
       
  int(XPRS_CC* XPRSgetstringcontrol)(XPRSprob prob, int _index, char* _svalue, int _svaluesize,

     

       
109
       
109
       
+
       
                                     int* _controlsize);

     

       
110
       
110
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
111
       
111
       
-
       
  int(XPRS_CC* XPRSsetstrcontrol)(XPRSprob prob, int index, const char* svalue);

     

       
111
       
111
       
+
       
  int(XPRS_CC* XPRSsetstrcontrol)(XPRSprob prob, int _index, const char* _svalue);

     

       
112
       
112
       
 
       


     

       
113
       
113
       
 
       
private:

     

       
114
       
114
       
 
       
  void loadDll();

     
···

       
130
       
130
       
 
       
    int msgLevel = 0;

     

       
131
       
131
       
 
       
    int timeout = 0;

     

       
132
       
132
       
 
       
    int numSolutions = 0;

     

       
133
       
133
       
-
       
    std::string logFile;

     

       
134
       
134
       
-
       
    std::string writeModelFile;

     

       
133
       
133
       
+
       
    std::string logFile = "";

     

       
134
       
134
       
+
       
    std::string writeModelFile = "";

     

       
135
       
135
       
 
       
    std::string writeModelFormat = "lp";

     

       
136
       
136
       
 
       
    double absGap = 0;

     

       
137
       
137
       
 
       
    double relGap = 0.0001;

     

···

       
41
       
41
       
 
       


     

       
42
       
42
       
 
       
namespace MiniZinc {

     

       
43
       
43
       
 
       


     

       
44
       
44
       
-
       
// #define MZN_PRINTATONCE_

     

       
45
       
45
       
-
       
#ifdef MZN_PRINTATONCE_

     

       
46
       
46
       
-
       
#define MZN_PRINT_SRCLOC(e1, e2)                                                            \

     

       
44
       
44
       
+
       
// #define __MZN_PRINTATONCE__

     

       
45
       
45
       
+
       
#ifdef __MZN_PRINTATONCE__

     

       
46
       
46
       
+
       
#define __MZN_PRINT_SRCLOC(e1, e2)                                                          \

     

       
47
       
47
       
 
       
  std::cerr << '\n'                                                                         \

     

       
48
       
48
       
 
       
            << __FILE__ << ": " << __LINE__ << " (" << __func__ << "): not " << e1 << ":  " \

     

       
49
       
49
       
 
       
            << std::flush;                                                                  \

     

       
50
       
50
       
 
       
  std::cerr << e2 << std::endl

     

       
51
       
51
       
 
       
#else

     

       
52
       
52
       
-
       
#define MZN_PRINT_SRCLOC(e1, e2)

     

       
52
       
52
       
+
       
#define __MZN_PRINT_SRCLOC(e1, e2)

     

       
53
       
53
       
 
       
#endif

     

       
54
       
54
       
-
       
#define MZN_ASSERT_HARD(c)      \

     

       
55
       
55
       
-
       
  do {                          \

     

       
56
       
56
       
-
       
    if (!(c)) {                 \

     

       
57
       
57
       
-
       
      MZN_PRINT_SRCLOC(#c, ""); \

     

       
58
       
58
       
-
       
      throw InternalError(#c);  \

     

       
59
       
59
       
-
       
    }                           \

     

       
54
       
54
       
+
       
#define MZN_ASSERT_HARD(c)        \

     

       
55
       
55
       
+
       
  do {                            \

     

       
56
       
56
       
+
       
    if (!(c)) {                   \

     

       
57
       
57
       
+
       
      __MZN_PRINT_SRCLOC(#c, ""); \

     

       
58
       
58
       
+
       
      throw InternalError(#c);    \

     

       
59
       
59
       
+
       
    }                             \

     

       
60
       
60
       
 
       
  } while (0)

     

       
61
       
61
       
 
       
#define MZN_ASSERT_HARD_MSG(c, e)                                                 \

     

       
62
       
62
       
 
       
  do {                                                                            \

     

       
63
       
63
       
 
       
    if (!(c)) {                                                                   \

     

       
64
       
64
       
-
       
      MZN_PRINT_SRCLOC(#c, e);                                                    \

     

       
64
       
64
       
+
       
      __MZN_PRINT_SRCLOC(#c, e);                                                  \

     

       
65
       
65
       
 
       
      std::ostringstream oss;                                                     \

     

       
66
       
66
       
 
       
      oss << "not " << #c << ":  " << e; /* NOLINT(bugprone-macro-parentheses) */ \

     

       
67
       
67
       
 
       
      throw MiniZinc::InternalError(oss.str());                                   \

     

···

       
42
       
42
       
 
       
///  TODO use integer division instead of INT_EPS

     

       
43
       
43
       
 
       
#define INT_EPS 1e-5  // the absolute epsilon for integrality of integer vars.

     

       
44
       
44
       
 
       


     

       
45
       
45
       
-
       
#define MZN_MIPDOMAINS_PRINTMORESTATS

     

       
45
       
45
       
+
       
#define __MZN__MIPDOMAINS__PRINTMORESTATS

     

       
46
       
46
       
 
       
#define MZN_DBG_CHECK_ITER_CUTOUT

     

       
47
       
47
       
 
       


     

       
48
       
48
       
-
       
//   #define MZN_DBGOUT_MIPDOMAINS

     

       
49
       
49
       
-
       
#ifdef MZN_DBGOUT_MIPDOMAINS

     

       
48
       
48
       
+
       
//   #define __MZN__DBGOUT__MIPDOMAINS__

     

       
49
       
49
       
+
       
#ifdef __MZN__DBGOUT__MIPDOMAINS__

     

       
50
       
50
       
 
       
#define DBGOUT_MIPD(s) std::cerr << s << std::endl

     

       
51
       
51
       
-
       
#define DBGOUT_MIPD_FLUSH(s) std::cerr << s << std::flush

     

       
51
       
51
       
+
       
#define DBGOUT_MIPD__(s) std::cerr << s << std::flush

     

       
52
       
52
       
 
       
#define DBGOUT_MIPD_SELF(op) op

     

       
53
       
53
       
 
       
#else

     

       
54
       
54
       
 
       
#define DBGOUT_MIPD(s) \

     

       
55
       
55
       
 
       
  do {                 \

     

       
56
       
56
       
 
       
  } while (false)

     

       
57
       
57
       
-
       
#define DBGOUT_MIPD_FLUSH(s) \

     

       
58
       
58
       
-
       
  do {                       \

     

       
57
       
57
       
+
       
#define DBGOUT_MIPD__(s) \

     

       
58
       
58
       
+
       
  do {                   \

     

       
59
       
59
       
 
       
  } while (false)

     

       
60
       
60
       
 
       
#define DBGOUT_MIPD_SELF(op) \

     

       
61
       
61
       
 
       
  do {                       \

     
···

       
64
       
64
       
 
       


     

       
65
       
65
       
 
       
namespace MiniZinc {

     

       
66
       
66
       
 
       


     

       
67
       
67
       
-
       
enum EnumStatIdx_MIPD {

     

       
68
       
68
       
-
       
  N_POSTs_all,  // N all POSTs in the model

     

       
69
       
69
       
-
       
  N_POSTs_intCmpReif,

     

       
70
       
70
       
-
       
  N_POSTs_floatCmpReif,  // in detail

     

       
71
       
71
       
-
       
  N_POSTs_intNE,

     

       
72
       
72
       
-
       
  N_POSTs_floatNE,

     

       
73
       
73
       
-
       
  N_POSTs_setIn,

     

       
74
       
74
       
-
       
  N_POSTs_domain,

     

       
75
       
75
       
-
       
  N_POSTs_setInReif,

     

       
76
       
76
       
-
       
  N_POSTs_eq_encode,

     

       
77
       
77
       
-
       
  N_POSTs_intAux,

     

       
78
       
78
       
-
       
  N_POSTs_floatAux,

     

       
67
       
67
       
+
       
enum EnumStatIdx__MIPD {

     

       
68
       
68
       
+
       
  N_POSTs__all,  // N all POSTs in the model

     

       
69
       
69
       
+
       
  N_POSTs__intCmpReif,

     

       
70
       
70
       
+
       
  N_POSTs__floatCmpReif,  // in detail

     

       
71
       
71
       
+
       
  N_POSTs__intNE,

     

       
72
       
72
       
+
       
  N_POSTs__floatNE,

     

       
73
       
73
       
+
       
  N_POSTs__setIn,

     

       
74
       
74
       
+
       
  N_POSTs__domain,

     

       
75
       
75
       
+
       
  N_POSTs__setInReif,

     

       
76
       
76
       
+
       
  N_POSTs__eq_encode,

     

       
77
       
77
       
+
       
  N_POSTs__intAux,

     

       
78
       
78
       
+
       
  N_POSTs__floatAux,

     

       
79
       
79
       
 
       
  // Kind of equality connections between involved variables

     

       
80
       
80
       
-
       
  N_POSTs_eq2intlineq,

     

       
81
       
81
       
-
       
  N_POSTs_eq2floatlineq,

     

       
82
       
82
       
-
       
  N_POSTs_int2float,

     

       
83
       
83
       
-
       
  N_POSTs_internalvarredef,

     

       
84
       
84
       
-
       
  N_POSTs_initexpr1id,

     

       
85
       
85
       
-
       
  N_POSTs_initexpr1linexp,

     

       
86
       
86
       
-
       
  N_POSTs_initexprN,

     

       
87
       
87
       
-
       
  N_POSTs_eqNlineq,

     

       
88
       
88
       
-
       
  N_POSTs_eqNmapsize,

     

       
80
       
80
       
+
       
  N_POSTs__eq2intlineq,

     

       
81
       
81
       
+
       
  N_POSTs__eq2floatlineq,

     

       
82
       
82
       
+
       
  N_POSTs__int2float,

     

       
83
       
83
       
+
       
  N_POSTs__internalvarredef,

     

       
84
       
84
       
+
       
  N_POSTs__initexpr1id,

     

       
85
       
85
       
+
       
  N_POSTs__initexpr1linexp,

     

       
86
       
86
       
+
       
  N_POSTs__initexprN,

     

       
87
       
87
       
+
       
  N_POSTs__eqNlineq,

     

       
88
       
88
       
+
       
  N_POSTs__eqNmapsize,

     

       
89
       
89
       
 
       
  // other

     

       
90
       
90
       
-
       
  N_POSTs_varsDirect,

     

       
91
       
91
       
-
       
  N_POSTs_varsInvolved,

     

       
92
       
92
       
-
       
  N_POSTs_NSubintvMin,

     

       
93
       
93
       
-
       
  N_POSTs_NSubintvSum,

     

       
94
       
94
       
-
       
  N_POSTs_NSubintvMax,  // as N subintervals

     

       
95
       
95
       
-
       
  N_POSTs_SubSizeMin,

     

       
96
       
96
       
-
       
  N_POSTs_SubSizeSum,

     

       
97
       
97
       
-
       
  N_POSTs_SubSizeMax,  // subintv. size

     

       
98
       
98
       
-
       
  N_POSTs_linCoefMin,

     

       
99
       
99
       
-
       
  N_POSTs_linCoefMax,

     

       
100
       
100
       
-
       
  N_POSTs_cliquesWithEqEncode,

     

       
101
       
101
       
-
       
  N_POSTs_clEEEnforced,

     

       
102
       
102
       
-
       
  N_POSTs_clEEFound,

     

       
103
       
103
       
-
       
  N_POSTs_size

     

       
90
       
90
       
+
       
  N_POSTs__varsDirect,

     

       
91
       
91
       
+
       
  N_POSTs__varsInvolved,

     

       
92
       
92
       
+
       
  N_POSTs__NSubintvMin,

     

       
93
       
93
       
+
       
  N_POSTs__NSubintvSum,

     

       
94
       
94
       
+
       
  N_POSTs__NSubintvMax,  // as N subintervals

     

       
95
       
95
       
+
       
  N_POSTs__SubSizeMin,

     

       
96
       
96
       
+
       
  N_POSTs__SubSizeSum,

     

       
97
       
97
       
+
       
  N_POSTs__SubSizeMax,  // subintv. size

     

       
98
       
98
       
+
       
  N_POSTs__linCoefMin,

     

       
99
       
99
       
+
       
  N_POSTs__linCoefMax,

     

       
100
       
100
       
+
       
  N_POSTs__cliquesWithEqEncode,

     

       
101
       
101
       
+
       
  N_POSTs__clEEEnforced,

     

       
102
       
102
       
+
       
  N_POSTs__clEEFound,

     

       
103
       
103
       
+
       
  N_POSTs__size

     

       
104
       
104
       
 
       
};

     

       
105
       
105
       
-
       
extern std::vector<double> MIPD_stats;

     

       
105
       
105
       
+
       
extern std::vector<double> MIPD__stats;

     

       
106
       
106
       
 
       


     

       
107
       
107
       
 
       
enum EnumReifType { RIT_None, RIT_Static, RIT_Reif, RIT_Halfreif };

     

       
108
       
108
       
 
       
enum EnumConstrType { CT_None, CT_Comparison, CT_SetIn, CT_Encode };

     
···

       
134
       
134
       
 
       
  FunctionI*& pfi;

     

       
135
       
135
       
 
       
  //     double dEps = -1.0;

     

       
136
       
136
       
 
       
  DCT(const char* fn, const std::vector<Type>& prm, EnumReifType er, EnumConstrType ec,

     

       
137
       
137
       
-
       
      EnumCmpType ecmp, EnumVarType ev, FunctionI*& pfi_)

     

       
137
       
137
       
+
       
      EnumCmpType ecmp, EnumVarType ev, FunctionI*& pfi__)

     

       
138
       
138
       
 
       
      : sFuncName(fn),

     

       
139
       
139
       
 
       
        aParams(prm),

     

       
140
       
140
       
 
       
        nReifType(er),

     

       
141
       
141
       
 
       
        nConstrType(ec),

     

       
142
       
142
       
 
       
        nCmpType(ecmp),

     

       
143
       
143
       
 
       
        nVarType(ev),

     

       
144
       
144
       
-
       
        pfi(pfi_) {}

     

       
144
       
144
       
+
       
        pfi(pfi__) {}

     

       
145
       
145
       
 
       
};

     

       
146
       
146
       
 
       


     

       
147
       
147
       
 
       
template <class N>

     
···

       
266
       
266
       
 
       
//       double rhs;

     

       
267
       
267
       
 
       
//     };

     

       
268
       
268
       
 
       


     

       
269
       
269
       
-
       
std::vector<double> MIPD_stats(N_POSTs_size);

     

       
269
       
269
       
+
       
std::vector<double> MIPD__stats(N_POSTs__size);

     

       
270
       
270
       
 
       


     

       
271
       
271
       
 
       
template <class T>

     

       
272
       
272
       
 
       
static std::vector<T> make_vec(T t1, T t2) {

     
···

       
299
       
299
       
 
       
  const double dMaxNValueDensity = 3.0;  // Maximal ratio cardInt() / size() of a domain

     

       
300
       
300
       
 
       
                                         // to enforce ee

     

       
301
       
301
       
 
       
  bool doMIPdomains() {

     

       
302
       
302
       
-
       
    MIPD_stats[N_POSTs_NSubintvMin] = 1e100;

     

       
303
       
303
       
-
       
    MIPD_stats[N_POSTs_SubSizeMin] = 1e100;

     

       
302
       
302
       
+
       
    MIPD__stats[N_POSTs__NSubintvMin] = 1e100;

     

       
303
       
303
       
+
       
    MIPD__stats[N_POSTs__SubSizeMin] = 1e100;

     

       
304
       
304
       
 
       


     

       
305
       
305
       
 
       
    if (!registerLinearConstraintDecls()) {

     

       
306
       
306
       
 
       
      return true;

     
···

       
325
       
325
       
 
       
private:

     

       
326
       
326
       
 
       
  Env* _env = nullptr;

     

       
327
       
327
       
 
       
  Env* getEnv() {

     

       
328
       
328
       
-
       
    MZN_MIPD_assert_hard(_env);

     

       
328
       
328
       
+
       
    MZN_MIPD__assert_hard(_env);

     

       
329
       
329
       
 
       
    return _env;

     

       
330
       
330
       
 
       
  }

     

       
331
       
331
       
 
       


     
···

       
354
       
354
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
355
       
355
       
 
       
  std::vector<Type> t_VIVF = make_vec(Type::varint(), Type::varfloat());

     

       
356
       
356
       
 
       


     

       
357
       
357
       
-
       
  //     double float_lt_EPS_coef_ = 1e-5;

     

       
357
       
357
       
+
       
  //     double float_lt_EPS_coef__ = 1e-5;

     

       
358
       
358
       
 
       


     

       
359
       
359
       
 
       
  bool registerLinearConstraintDecls() {

     

       
360
       
360
       
 
       
    EnvI& env = getEnv()->envi();

     
···

       
362
       
362
       
 
       


     

       
363
       
363
       
 
       
    int_lin_eq = env.model->matchFn(env, constants().ids.int_.lin_eq, int_lin_eq_t, false);

     

       
364
       
364
       
 
       
    DBGOUT_MIPD("  int_lin_eq = " << int_lin_eq);

     

       
365
       
365
       
-
       
    //       MZN_MIPD_assert_hard(fi);

     

       
365
       
365
       
+
       
    //       MZN_MIPD__assert_hard(fi);

     

       
366
       
366
       
 
       
    //       int_lin_eq = (fi && fi->e()) ? fi : NULL;

     

       
367
       
367
       
 
       
    int_lin_le = env.model->matchFn(env, constants().ids.int_.lin_le, int_lin_eq_t, false);

     

       
368
       
368
       
 
       
    float_lin_eq = env.model->matchFn(env, constants().ids.float_.lin_eq, float_lin_eq_t, false);

     
···

       
385
       
385
       
 
       
    //           new Call(Location(),"mzn_float_lt_EPS_coef__", std::vector<Expression*>());

     

       
386
       
386
       
 
       
    //         call_EPS_for_LT->type(Type::parfloat());

     

       
387
       
387
       
 
       
    //         call_EPS_for_LT->decl(env.model->matchFn(getEnv()->envi(), call_EPS_for_LT));

     

       
388
       
388
       
-
       
    //         float_lt_EPS_coef_ = eval_float(getEnv()->envi(), call_EPS_for_LT);

     

       
388
       
388
       
+
       
    //         float_lt_EPS_coef__ = eval_float(getEnv()->envi(), call_EPS_for_LT);

     

       
389
       
389
       
 
       
    //       }

     

       
390
       
390
       
 
       
  }

     

       
391
       
391
       
 
       
  //   bool matchAndMarkFunction();

     
···

       
431
       
431
       
 
       
  //     std::vector<Type> t_intarray(1);

     

       
432
       
432
       
 
       
  //     t_intarray[0] = Type::parint(-1);

     

       
433
       
433
       
 
       


     

       
434
       
434
       
-
       
  typedef std::unordered_map<FunctionI*, DCT*> M_POSTCallTypes;

     

       
435
       
435
       
-
       
  M_POSTCallTypes _mCallTypes;  // actually declared in the input

     

       
436
       
436
       
-
       
  std::vector<DCT> _aCT;        // all possible

     

       
434
       
434
       
+
       
  typedef std::unordered_map<FunctionI*, DCT*> M__POSTCallTypes;

     

       
435
       
435
       
+
       
  M__POSTCallTypes _mCallTypes;  // actually declared in the input

     

       
436
       
436
       
+
       
  std::vector<DCT> _aCT;         // all possible

     

       
437
       
437
       
 
       


     

       
438
       
438
       
 
       
  // Fails:

     

       
439
       
439
       
 
       
  //   DomainCallType a = { NULL, t_VII, RIT_Halfreif, CT_Comparison, CMPT_EQ, VT_Float };

     
···

       
458
       
458
       
 
       
  std::vector<VarDescr> _vVarDescr;

     

       
459
       
459
       
 
       


     

       
460
       
460
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
461
       
461
       
-
       
  FunctionI* int_le_reif_POST = nullptr;

     

       
461
       
461
       
+
       
  FunctionI* int_le_reif__POST = nullptr;

     

       
462
       
462
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
463
       
463
       
-
       
  FunctionI* int_ge_reif_POST = nullptr;

     

       
463
       
463
       
+
       
  FunctionI* int_ge_reif__POST = nullptr;

     

       
464
       
464
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
465
       
465
       
-
       
  FunctionI* int_eq_reif_POST = nullptr;

     

       
465
       
465
       
+
       
  FunctionI* int_eq_reif__POST = nullptr;

     

       
466
       
466
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
467
       
467
       
-
       
  FunctionI* int_ne_POST = nullptr;

     

       
467
       
467
       
+
       
  FunctionI* int_ne__POST = nullptr;

     

       
468
       
468
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
469
       
469
       
-
       
  FunctionI* float_le_reif_POST = nullptr;

     

       
469
       
469
       
+
       
  FunctionI* float_le_reif__POST = nullptr;

     

       
470
       
470
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
471
       
471
       
-
       
  FunctionI* float_ge_reif_POST = nullptr;

     

       
471
       
471
       
+
       
  FunctionI* float_ge_reif__POST = nullptr;

     

       
472
       
472
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
473
       
473
       
-
       
  FunctionI* aux_float_lt_zero_iff_1_POST = nullptr;

     

       
473
       
473
       
+
       
  FunctionI* aux_float_lt_zero_iff_1__POST = nullptr;

     

       
474
       
474
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
475
       
475
       
-
       
  FunctionI* float_eq_reif_POST = nullptr;

     

       
475
       
475
       
+
       
  FunctionI* float_eq_reif__POST = nullptr;

     

       
476
       
476
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
477
       
477
       
-
       
  FunctionI* float_ne_POST = nullptr;

     

       
477
       
477
       
+
       
  FunctionI* float_ne__POST = nullptr;

     

       
478
       
478
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
479
       
479
       
-
       
  FunctionI* aux_float_eq_zero_if_1_POST = nullptr;

     

       
479
       
479
       
+
       
  FunctionI* aux_float_eq_zero_if_1__POST = nullptr;

     

       
480
       
480
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
481
       
481
       
-
       
  FunctionI* aux_int_le_zero_if_1_POST = nullptr;

     

       
481
       
481
       
+
       
  FunctionI* aux_int_le_zero_if_1__POST = nullptr;

     

       
482
       
482
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
483
       
483
       
-
       
  FunctionI* aux_float_le_zero_if_1_POST = nullptr;

     

       
483
       
483
       
+
       
  FunctionI* aux_float_le_zero_if_1__POST = nullptr;

     

       
484
       
484
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
485
       
485
       
-
       
  FunctionI* aux_float_lt_zero_if_1_POST = nullptr;

     

       
485
       
485
       
+
       
  FunctionI* aux_float_lt_zero_if_1__POST = nullptr;

     

       
486
       
486
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
487
       
487
       
-
       
  FunctionI* equality_encoding_POST = nullptr;

     

       
487
       
487
       
+
       
  FunctionI* equality_encoding__POST = nullptr;

     

       
488
       
488
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
489
       
489
       
-
       
  FunctionI* set_in_POST = nullptr;

     

       
489
       
489
       
+
       
  FunctionI* set_in__POST = nullptr;

     

       
490
       
490
       
 
       
  // NOLINTNEXTLINE(readability-identifier-naming)

     

       
491
       
491
       
-
       
  FunctionI* set_in_reif_POST = nullptr;

     

       
491
       
491
       
+
       
  FunctionI* set_in_reif__POST = nullptr;

     

       
492
       
492
       
 
       


     

       
493
       
493
       
 
       
  bool registerPOSTConstraintDecls() {

     

       
494
       
494
       
 
       
    EnvI& env = getEnv()->envi();

     
···

       
496
       
496
       
 
       


     

       
497
       
497
       
 
       
    _aCT.clear();

     

       
498
       
498
       
 
       
    _aCT.emplace_back("int_le_reif__POST", t_VIIVI, RIT_Reif, CT_Comparison, CMPT_LE, VT_Int,

     

       
499
       
499
       
-
       
                      int_le_reif_POST);

     

       
499
       
499
       
+
       
                      int_le_reif__POST);

     

       
500
       
500
       
 
       
    _aCT.emplace_back("int_ge_reif__POST", t_VIIVI, RIT_Reif, CT_Comparison, CMPT_GE, VT_Int,

     

       
501
       
501
       
-
       
                      int_ge_reif_POST);

     

       
501
       
501
       
+
       
                      int_ge_reif__POST);

     

       
502
       
502
       
 
       
    _aCT.emplace_back("int_eq_reif__POST", t_VIIVI, RIT_Reif, CT_Comparison, CMPT_EQ, VT_Int,

     

       
503
       
503
       
-
       
                      int_eq_reif_POST);

     

       
503
       
503
       
+
       
                      int_eq_reif__POST);

     

       
504
       
504
       
 
       
    _aCT.emplace_back("int_ne__POST", t_VII, RIT_Static, CT_Comparison, CMPT_NE, VT_Int,

     

       
505
       
505
       
-
       
                      int_ne_POST);

     

       
505
       
505
       
+
       
                      int_ne__POST);

     

       
506
       
506
       
 
       


     

       
507
       
507
       
 
       
    _aCT.emplace_back("float_le_reif__POST", t_VFFVIF, RIT_Reif, CT_Comparison, CMPT_LE, VT_Float,

     

       
508
       
508
       
-
       
                      float_le_reif_POST);

     

       
508
       
508
       
+
       
                      float_le_reif__POST);

     

       
509
       
509
       
 
       
    _aCT.emplace_back("float_ge_reif__POST", t_VFFVIF, RIT_Reif, CT_Comparison, CMPT_GE, VT_Float,

     

       
510
       
510
       
-
       
                      float_ge_reif_POST);

     

       
510
       
510
       
+
       
                      float_ge_reif__POST);

     

       
511
       
511
       
 
       
    _aCT.emplace_back("aux_float_lt_zero_iff_1__POST", t_VFVIF, RIT_Reif, CT_Comparison, CMPT_LT,

     

       
512
       
512
       
-
       
                      VT_Float, aux_float_lt_zero_iff_1_POST);

     

       
512
       
512
       
+
       
                      VT_Float, aux_float_lt_zero_iff_1__POST);

     

       
513
       
513
       
 
       
    _aCT.emplace_back("float_eq_reif__POST", t_VFFVIF, RIT_Reif, CT_Comparison, CMPT_EQ, VT_Float,

     

       
514
       
514
       
-
       
                      float_eq_reif_POST);

     

       
514
       
514
       
+
       
                      float_eq_reif__POST);

     

       
515
       
515
       
 
       
    _aCT.emplace_back("float_ne__POST", t_VFFF, RIT_Static, CT_Comparison, CMPT_NE, VT_Float,

     

       
516
       
516
       
-
       
                      float_ne_POST);

     

       
516
       
516
       
+
       
                      float_ne__POST);

     

       
517
       
517
       
 
       


     

       
518
       
518
       
 
       
    _aCT.emplace_back("aux_float_eq_zero_if_1__POST", t_VFVIVF, RIT_Halfreif, CT_Comparison,

     

       
519
       
519
       
-
       
                      CMPT_EQ_0, VT_Float, aux_float_eq_zero_if_1_POST);

     

       
519
       
519
       
+
       
                      CMPT_EQ_0, VT_Float, aux_float_eq_zero_if_1__POST);

     

       
520
       
520
       
 
       
    _aCT.emplace_back("aux_int_le_zero_if_1__POST", t_VIVI, RIT_Halfreif, CT_Comparison, CMPT_LE_0,

     

       
521
       
521
       
-
       
                      VT_Int, aux_int_le_zero_if_1_POST);

     

       
521
       
521
       
+
       
                      VT_Int, aux_int_le_zero_if_1__POST);

     

       
522
       
522
       
 
       
    _aCT.emplace_back("aux_float_le_zero_if_1__POST", t_VFVIVF, RIT_Halfreif, CT_Comparison,

     

       
523
       
523
       
-
       
                      CMPT_LE_0, VT_Float, aux_float_le_zero_if_1_POST);

     

       
523
       
523
       
+
       
                      CMPT_LE_0, VT_Float, aux_float_le_zero_if_1__POST);

     

       
524
       
524
       
 
       
    _aCT.emplace_back("aux_float_lt_zero_if_1__POST", t_VFVIVFF, RIT_Halfreif, CT_Comparison,

     

       
525
       
525
       
-
       
                      CMPT_LT_0, VT_Float, aux_float_lt_zero_if_1_POST);

     

       
525
       
525
       
+
       
                      CMPT_LT_0, VT_Float, aux_float_lt_zero_if_1__POST);

     

       
526
       
526
       
 
       


     

       
527
       
527
       
 
       
    _aCT.emplace_back("equality_encoding__POST", t_VIAVI, RIT_Static, CT_Encode, CMPT_None, VT_Int,

     

       
528
       
528
       
-
       
                      equality_encoding_POST);

     

       
529
       
529
       
-
       
    _aCT.emplace_back("set_in__POST", t_VISI, RIT_Static, CT_SetIn, CMPT_None, VT_Int, set_in_POST);

     

       
528
       
528
       
+
       
                      equality_encoding__POST);

     

       
529
       
529
       
+
       
    _aCT.emplace_back("set_in__POST", t_VISI, RIT_Static, CT_SetIn, CMPT_None, VT_Int,

     

       
530
       
530
       
+
       
                      set_in__POST);

     

       
530
       
531
       
 
       
    _aCT.emplace_back("set_in_reif__POST", t_VISIVI, RIT_Reif, CT_SetIn, CMPT_None, VT_Int,

     

       
531
       
531
       
-
       
                      set_in_reif_POST);

     

       
532
       
532
       
-
       
    /// Registering all declared & compatible _POST constraints

     

       
532
       
532
       
+
       
                      set_in_reif__POST);

     

       
533
       
533
       
+
       
    /// Registering all declared & compatible __POST constraints

     

       
533
       
534
       
 
       
    /// (First, cleanup FunctionIs' payload:  -- ! doing now)

     

       
534
       
535
       
 
       
    for (int i = 0; i < _aCT.size(); ++i) {

     

       
535
       
536
       
 
       
      FunctionI* fi = env.model->matchFn(env, ASTString(_aCT[i].sFuncName), _aCT[i].aParams, false);

     
···

       
547
       
548
       
 
       
    return true;

     

       
548
       
549
       
 
       
  }

     

       
549
       
550
       
 
       


     

       
550
       
550
       
-
       
  /// Registering all _POST calls' domain-constrained variables

     

       
551
       
551
       
+
       
  /// Registering all __POST calls' domain-constrained variables

     

       
551
       
552
       
 
       
  void registerPOSTVariables() {

     

       
552
       
553
       
 
       
    EnvI& env = getEnv()->envi();

     

       
553
       
554
       
 
       
    GCLock lock;

     
···

       
576
       
577
       
 
       
            checkInitExpr(vd0);

     

       
577
       
578
       
 
       
          }

     

       
578
       
579
       
 
       
        } else {

     

       
579
       
579
       
-
       
          DBGOUT_MIPD_FLUSH(" (already touched)");

     

       
580
       
580
       
+
       
          DBGOUT_MIPD__(" (already touched)");

     

       
580
       
581
       
 
       
        }

     

       
581
       
581
       
-
       
        ++MIPD_stats[N_POSTs_domain];

     

       
582
       
582
       
-
       
        ++MIPD_stats[N_POSTs_all];

     

       
582
       
582
       
+
       
        ++MIPD__stats[N_POSTs__domain];

     

       
583
       
583
       
+
       
        ++MIPD__stats[N_POSTs__all];

     

       
583
       
584
       
 
       
      }

     

       
584
       
585
       
 
       
    }

     

       
585
       
585
       
-
       
    // Iterate thru original _POST constraints to mark constrained vars:

     

       
586
       
586
       
+
       
    // Iterate thru original __POST constraints to mark constrained vars:

     

       
586
       
587
       
 
       
    for (ConstraintIterator ic = mFlat.constraints().begin(); ic != mFlat.constraints().end();

     

       
587
       
588
       
 
       
         ++ic) {

     

       
588
       
589
       
 
       
      if (ic->removed()) {

     
···

       
593
       
594
       
 
       
        if (ipct != _mCallTypes.end()) {

     

       
594
       
595
       
 
       
          // No ! here because might be deleted immediately in later versions.

     

       
595
       
596
       
 
       
          //             ic->remove();                              // mark removed at once

     

       
596
       
596
       
-
       
          MZN_MIPD_assert_hard(c->argCount() > 1);

     

       
597
       
597
       
-
       
          ++MIPD_stats[N_POSTs_all];

     

       
597
       
597
       
+
       
          MZN_MIPD__assert_hard(c->argCount() > 1);

     

       
598
       
598
       
+
       
          ++MIPD__stats[N_POSTs__all];

     

       
598
       
599
       
 
       
          VarDecl* vd0 = expr2VarDecl(c->arg(0));

     

       
599
       
600
       
 
       
          if (nullptr == vd0) {

     

       
600
       
600
       
-
       
            DBGOUT_MIPD_FLUSH("  Call " << *c

     

       
601
       
601
       
-
       
                                        << ": 1st arg not a VarDecl, removing if eq_encoding...");

     

       
601
       
601
       
+
       
            DBGOUT_MIPD__("  Call " << *c << ": 1st arg not a VarDecl, removing if eq_encoding...");

     

       
602
       
602
       
 
       
            /// Only allow literals as main argument for equality_encoding

     

       
603
       
603
       
-
       
            if (equality_encoding_POST ==

     

       
604
       
604
       
-
       
                ipct->first) {  //  was MZN_MIPD_assert_hard before MZN 2017

     

       
603
       
603
       
+
       
            if (equality_encoding__POST ==

     

       
604
       
604
       
+
       
                ipct->first) {  //  was MZN_MIPD__assert_hard before MZN 2017

     

       
605
       
605
       
 
       
              ic->remove();

     

       
606
       
606
       
 
       
            }

     

       
607
       
607
       
 
       
            continue;  // ignore this call

     

       
608
       
608
       
 
       
          }

     

       
609
       
609
       
-
       
          DBGOUT_MIPD_FLUSH("  Call " << c->id().str() << " uses variable " << vd0->id()->str());

     

       
609
       
609
       
+
       
          DBGOUT_MIPD__("  Call " << c->id().str() << " uses variable " << vd0->id()->str());

     

       
610
       
610
       
 
       
          if (vd0->payload() == -1) {  // ! yet visited

     

       
611
       
611
       
 
       
            vd0->payload(static_cast<int>(_vVarDescr.size()));

     

       
612
       
612
       
 
       
            _vVarDescr.emplace_back(vd0, vd0->type().isint());  // can use /prmTypes/ as well

     
···

       
615
       
615
       
 
       
              checkInitExpr(vd0);

     

       
616
       
616
       
 
       
            }

     

       
617
       
617
       
 
       
          } else {

     

       
618
       
618
       
-
       
            DBGOUT_MIPD_FLUSH(" (already touched)");

     

       
618
       
618
       
+
       
            DBGOUT_MIPD__(" (already touched)");

     

       
619
       
619
       
 
       
          }

     

       
620
       
620
       
 
       
          DBGOUT_MIPD("");

     

       
621
       
621
       
-
       
          if (equality_encoding_POST == c->decl()) {

     

       
622
       
622
       
-
       
            MZN_MIPD_assert_hard(!_vVarDescr[vd0->payload()].pEqEncoding);

     

       
621
       
621
       
+
       
          if (equality_encoding__POST == c->decl()) {

     

       
622
       
622
       
+
       
            MZN_MIPD__assert_hard(!_vVarDescr[vd0->payload()].pEqEncoding);

     

       
623
       
623
       
 
       
            _vVarDescr[vd0->payload()].pEqEncoding = &*ic;

     

       
624
       
624
       
 
       
            DBGOUT_MIPD(" Variable " << vd0->id()->str() << " has eq_encode.");

     

       
625
       
625
       
 
       
          }  // + if has aux_ constraints?

     
···

       
629
       
629
       
 
       
        }

     

       
630
       
630
       
 
       
      }

     

       
631
       
631
       
 
       
    }

     

       
632
       
632
       
-
       
    MIPD_stats[N_POSTs_varsDirect] = static_cast<double>(_vVarDescr.size());

     

       
632
       
632
       
+
       
    MIPD__stats[N_POSTs__varsDirect] = static_cast<double>(_vVarDescr.size());

     

       
633
       
633
       
 
       
  }

     

       
634
       
634
       
 
       


     

       
635
       
635
       
 
       
  // Should only be called on a newly added variable

     
···

       
639
       
639
       
 
       
  /// The bool param requires RHS to be POST-touched

     

       
640
       
640
       
 
       
  // Guido: can! be recursive in FZN

     

       
641
       
641
       
 
       
  bool checkInitExpr(VarDecl* vd, bool fCheckArg = false) {

     

       
642
       
642
       
-
       
    MZN_MIPD_assert_hard(vd->e());

     

       
642
       
642
       
+
       
    MZN_MIPD__assert_hard(vd->e());

     

       
643
       
643
       
 
       
    if (!vd->type().isint() && !vd->type().isfloat()) {

     

       
644
       
644
       
 
       
      return false;

     

       
645
       
645
       
 
       
    }

     

       
646
       
646
       
 
       
    if (!fCheckArg) {

     

       
647
       
647
       
-
       
      MZN_MIPD_assert_hard(vd->payload() >= 0);

     

       
647
       
647
       
+
       
      MZN_MIPD__assert_hard(vd->payload() >= 0);

     

       
648
       
648
       
 
       
    }

     

       
649
       
649
       
 
       
    if (Id* id = vd->e()->dynamicCast<Id>()) {

     

       
650
       
650
       
 
       
      //         const int f1 = ( vd->payload()>=0 );

     

       
651
       
651
       
 
       
      //         const int f2 = ( id->decl()->payload()>=0 );

     

       
652
       
652
       
 
       
      if (!fCheckArg || (id->decl()->payload() >= 0)) {

     

       
653
       
653
       
-
       
        DBGOUT_MIPD_FLUSH("  Checking init expr  ");

     

       
653
       
653
       
+
       
        DBGOUT_MIPD__("  Checking init expr  ");

     

       
654
       
654
       
 
       
        DBGOUT_MIPD_SELF(debugprint(vd));

     

       
655
       
655
       
 
       
        LinEq2Vars led;

     

       
656
       
656
       
 
       
        // FAILS:

     
···

       
659
       
659
       
 
       
        led.coefs = {{1.0, -1.0}};

     

       
660
       
660
       
 
       
        led.rhs = 0.0;

     

       
661
       
661
       
 
       
        put2VarsConnection(led, false);

     

       
662
       
662
       
-
       
        ++MIPD_stats[N_POSTs_initexpr1id];

     

       
662
       
662
       
+
       
        ++MIPD__stats[N_POSTs__initexpr1id];

     

       
663
       
663
       
 
       
        if (id->decl()->e() != nullptr) {  // no initexpr for initexpr  FAILS on cc-base.mzn

     

       
664
       
664
       
 
       
          checkInitExpr(id->decl());

     

       
665
       
665
       
 
       
        }

     
···

       
669
       
669
       
 
       
      if (lin_exp_int == c->decl() || lin_exp_float == c->decl()) {

     

       
670
       
670
       
 
       
        //             std::cerr << "  !E call " << std::flush;

     

       
671
       
671
       
 
       
        //             debugprint(c);

     

       
672
       
672
       
-
       
        MZN_MIPD_assert_hard(c->argCount() == 3);

     

       
672
       
672
       
+
       
        MZN_MIPD__assert_hard(c->argCount() == 3);

     

       
673
       
673
       
 
       
        //           ArrayLit* al = c->args()[1]->dynamicCast<ArrayLit>();

     

       
674
       
674
       
 
       
        auto* al = follow_id(c->arg(1))->cast<ArrayLit>();

     

       
675
       
675
       
-
       
        MZN_MIPD_assert_hard(al);

     

       
676
       
676
       
-
       
        MZN_MIPD_assert_hard(al->size() >= 1);

     

       
675
       
675
       
+
       
        MZN_MIPD__assert_hard(al);

     

       
676
       
676
       
+
       
        MZN_MIPD__assert_hard(al->size() >= 1);

     

       
677
       
677
       
 
       
        if (al->size() == 1) {  // 1-term scalar product in the rhs

     

       
678
       
678
       
 
       
          LinEq2Vars led;

     

       
679
       
679
       
 
       
          led.vd = {{vd, expr2VarDecl((*al)[0])}};

     
···

       
684
       
684
       
 
       
            //               if ( _sCallLinEq2.end() != _sCallLinEq2.find(c) )

     

       
685
       
685
       
 
       
            //                 continue;

     

       
686
       
686
       
 
       
            //               _sCallLinEq2.insert(c);     // memorize this call

     

       
687
       
687
       
-
       
            DBGOUT_MIPD_FLUSH("  REG 1-LINEXP ");

     

       
687
       
687
       
+
       
            DBGOUT_MIPD__("  REG 1-LINEXP ");

     

       
688
       
688
       
 
       
            DBGOUT_MIPD_SELF(debugprint(vd));

     

       
689
       
689
       
 
       
            std::array<double, 1> coef0;

     

       
690
       
690
       
 
       
            expr2Array(c->arg(0), coef0);

     

       
691
       
691
       
 
       
            led.coefs = {{-1.0, coef0[0]}};

     

       
692
       
692
       
 
       
            led.rhs = -expr2Const(c->arg(2));  // MINUS

     

       
693
       
693
       
 
       
            put2VarsConnection(led, false);

     

       
694
       
694
       
-
       
            ++MIPD_stats[N_POSTs_initexpr1linexp];

     

       
694
       
694
       
+
       
            ++MIPD__stats[N_POSTs__initexpr1linexp];

     

       
695
       
695
       
 
       
            if (led.vd[1]->e() != nullptr) {  // no initexpr for initexpr   FAILS  TODO

     

       
696
       
696
       
 
       
              checkInitExpr(led.vd[1]);

     

       
697
       
697
       
 
       
            }

     
···

       
726
       
726
       
 
       
      propagateImplViews(fChanges);

     

       
727
       
727
       
 
       
    } while (fChanges);

     

       
728
       
728
       
 
       


     

       
729
       
729
       
-
       
    MIPD_stats[N_POSTs_varsInvolved] = static_cast<double>(_vVarDescr.size());

     

       
729
       
729
       
+
       
    MIPD__stats[N_POSTs__varsInvolved] = static_cast<double>(_vVarDescr.size());

     

       
730
       
730
       
 
       
  }

     

       
731
       
731
       
 
       


     

       
732
       
732
       
 
       
  void propagateViews(bool& fChanges) {

     
···

       
764
       
764
       
 
       
        if (fIntLinEq || fFloatLinEq) {

     

       
765
       
765
       
 
       
          //             std::cerr << "  !E call " << std::flush;

     

       
766
       
766
       
 
       
          //             debugprint(c);

     

       
767
       
767
       
-
       
          MZN_MIPD_assert_hard(c->argCount() == 3);

     

       
767
       
767
       
+
       
          MZN_MIPD__assert_hard(c->argCount() == 3);

     

       
768
       
768
       
 
       
          auto* al = follow_id(c->arg(1))->cast<ArrayLit>();

     

       
769
       
769
       
-
       
          MZN_MIPD_assert_hard(al);

     

       
769
       
769
       
+
       
          MZN_MIPD__assert_hard(al);

     

       
770
       
770
       
 
       
          if (al->size() == 2) {  // 2-term eqn

     

       
771
       
771
       
 
       
            LinEq2Vars led;

     

       
772
       
772
       
 
       
            expr2DeclArray(c->arg(1), led.vd);

     
···

       
781
       
781
       
 
       
                DBGOUT_MIPD_SELF(debugprint(c));

     

       
782
       
782
       
 
       
                led.rhs = expr2Const(c->arg(2));

     

       
783
       
783
       
 
       
                expr2Array(c->arg(0), led.coefs);

     

       
784
       
784
       
-
       
                MZN_MIPD_assert_hard(2 == led.coefs.size());

     

       
784
       
784
       
+
       
                MZN_MIPD__assert_hard(2 == led.coefs.size());

     

       
785
       
785
       
 
       
                fChanges = true;

     

       
786
       
786
       
 
       
                put2VarsConnection(led);

     

       
787
       
787
       
-
       
                ++MIPD_stats[fIntLinEq ? N_POSTs_eq2intlineq : N_POSTs_eq2floatlineq];

     

       
787
       
787
       
+
       
                ++MIPD__stats[fIntLinEq ? N_POSTs__eq2intlineq : N_POSTs__eq2floatlineq];

     

       
788
       
788
       
 
       
              }

     

       
789
       
789
       
 
       
            }

     

       
790
       
790
       
 
       
          } else if (al->size() == 1) {

     
···

       
804
       
804
       
 
       
              DBGOUT_MIPD("       REG N-call ");

     

       
805
       
805
       
 
       
              DBGOUT_MIPD_SELF(debugprint(c));

     

       
806
       
806
       
 
       
              Call* pC = eVD->dynamicCast<Call>();

     

       
807
       
807
       
-
       
              MZN_MIPD_assert_hard(pC);

     

       
808
       
808
       
-
       
              MZN_MIPD_assert_hard(pC->argCount());

     

       
807
       
807
       
+
       
              MZN_MIPD__assert_hard(pC);

     

       
808
       
808
       
+
       
              MZN_MIPD__assert_hard(pC->argCount());

     

       
809
       
809
       
 
       
              // Checking all but adding only touched defined vars? Seems too long.

     

       
810
       
810
       
 
       
              VarDecl* vd = expr2VarDecl(pC->arg(0));

     

       
811
       
811
       
 
       
              if ((vd != nullptr) && vd->payload() >= 0) {  // only if touched

     
···

       
822
       
822
       
 
       
            if (int2float == c->decl() || constants().varRedef == c->decl()) {

     

       
823
       
823
       
 
       
          //             std::cerr << "  !E call " << std::flush;

     

       
824
       
824
       
 
       
          //             debugprint(c);

     

       
825
       
825
       
-
       
          MZN_MIPD_assert_hard(c->argCount() == 2);

     

       
825
       
825
       
+
       
          MZN_MIPD__assert_hard(c->argCount() == 2);

     

       
826
       
826
       
 
       
          LinEq2Vars led;

     

       
827
       
827
       
 
       
          //             led.vd.resize(2);

     

       
828
       
828
       
 
       
          led.vd[0] = expr2VarDecl(c->arg(0));

     
···

       
839
       
839
       
 
       
            led.coefs = {{1.0, -1.0}};

     

       
840
       
840
       
 
       
            fChanges = true;

     

       
841
       
841
       
 
       
            put2VarsConnection(led);

     

       
842
       
842
       
-
       
            ++MIPD_stats[int2float == c->decl() ? N_POSTs_int2float : N_POSTs_internalvarredef];

     

       
842
       
842
       
+
       
            ++MIPD__stats[int2float == c->decl() ? N_POSTs__int2float : N_POSTs__internalvarredef];

     

       
843
       
843
       
 
       
          }

     

       
844
       
844
       
 
       
        }

     

       
845
       
845
       
 
       
      }

     
···

       
865
       
865
       
 
       
  // _lin_eq: a^T x == b

     

       
866
       
866
       
 
       
  bool findOrAddDefining(Expression* exp, Call* pC) {

     

       
867
       
867
       
 
       
    Id* pId = exp->dynamicCast<Id>();

     

       
868
       
868
       
-
       
    MZN_MIPD_assert_hard(pId);

     

       
868
       
868
       
+
       
    MZN_MIPD__assert_hard(pId);

     

       
869
       
869
       
 
       
    VarDecl* vd = pId->decl();

     

       
870
       
870
       
-
       
    MZN_MIPD_assert_hard(vd);

     

       
871
       
871
       
-
       
    MZN_MIPD_assert_hard(pC->argCount() == 3);

     

       
870
       
870
       
+
       
    MZN_MIPD__assert_hard(vd);

     

       
871
       
871
       
+
       
    MZN_MIPD__assert_hard(pC->argCount() == 3);

     

       
872
       
872
       
 
       


     

       
873
       
873
       
 
       
    TLinExpLin rhsLin;

     

       
874
       
874
       
 
       
    NViewData nVRest;

     
···

       
879
       
879
       
 
       
    expr2DeclArray(pC->arg(1), vars);

     

       
880
       
880
       
 
       
    std::vector<double> coefs;

     

       
881
       
881
       
 
       
    expr2Array(pC->arg(0), coefs);

     

       
882
       
882
       
-
       
    MZN_MIPD_assert_hard(vars.size() == coefs.size());

     

       
882
       
882
       
+
       
    MZN_MIPD__assert_hard(vars.size() == coefs.size());

     

       
883
       
883
       
 
       


     

       
884
       
884
       
 
       
    int nVD = 0;

     

       
885
       
885
       
 
       
    for (int i = 0; i < vars.size(); ++i) {

     

       
886
       
886
       
-
       
      //         MZN_MIPD_assert_hard( 0.0!=std::fabs

     

       
886
       
886
       
+
       
      //         MZN_MIPD__assert_hard( 0.0!=std::fabs

     

       
887
       
887
       
 
       
      if (vd ==

     

       
888
       
888
       
 
       
          vars[i]) {  // when int/float_lin_eq :: defines_var(vd) "Recursive definition of " << *vd

     

       
889
       
889
       
 
       
        nVRest.coef0 = -coefs[i];

     
···

       
893
       
893
       
 
       
        rhsLin.push_back(std::make_pair(vars[i], coefs[i]));

     

       
894
       
894
       
 
       
      }

     

       
895
       
895
       
 
       
    }

     

       
896
       
896
       
-
       
    MZN_MIPD_assert_hard(1 >= nVD);

     

       
896
       
896
       
+
       
    MZN_MIPD__assert_hard(1 >= nVD);

     

       
897
       
897
       
 
       
    std::sort(rhsLin.begin(), rhsLin.end());

     

       
898
       
898
       
 
       


     

       
899
       
899
       
 
       
    // Divide the equation by the 1st coef

     

       
900
       
900
       
 
       
    const double coef1 = rhsLin.begin()->second;

     

       
901
       
901
       
-
       
    MZN_MIPD_assert_hard(0.0 != std::fabs(coef1));

     

       
901
       
901
       
+
       
    MZN_MIPD__assert_hard(0.0 != std::fabs(coef1));

     

       
902
       
902
       
 
       
    nVRest.coef0 /= coef1;

     

       
903
       
903
       
 
       
    nVRest.rhs /= coef1;

     

       
904
       
904
       
 
       
    for (auto& rhsL : rhsLin) {

     
···

       
913
       
913
       
 
       
      leq.coefs = {{nVRest.coef0, -it->second.coef0}};  // +, -

     

       
914
       
914
       
 
       
      leq.rhs = nVRest.rhs - it->second.rhs;

     

       
915
       
915
       
 
       
      put2VarsConnection(leq, false);

     

       
916
       
916
       
-
       
      ++MIPD_stats[nVD != 0 ? N_POSTs_eqNlineq : N_POSTs_initexprN];

     

       
916
       
916
       
+
       
      ++MIPD__stats[nVD != 0 ? N_POSTs__eqNlineq : N_POSTs__initexprN];

     

       
917
       
917
       
 
       
      return true;

     

       
918
       
918
       
 
       
    }

     

       
919
       
919
       
 
       
    if (vd->payload() >= 0) {  // only touched

     
···

       
948
       
948
       
 
       
  /// register a 2-variable lin eq

     

       
949
       
949
       
 
       
  /// add it to the var clique, joining the participants' cliques if needed

     

       
950
       
950
       
 
       
  void put2VarsConnection(LinEq2Vars& led, bool fCheckinitExpr = true) {

     

       
951
       
951
       
-
       
    MZN_MIPD_assert_hard(led.coefs.size() == led.vd.size());

     

       
952
       
952
       
-
       
    MZN_MIPD_assert_hard(led.vd.size() == 2);

     

       
953
       
953
       
-
       
    DBGOUT_MIPD_FLUSH("  Register 2-var connection: " << led);

     

       
951
       
951
       
+
       
    MZN_MIPD__assert_hard(led.coefs.size() == led.vd.size());

     

       
952
       
952
       
+
       
    MZN_MIPD__assert_hard(led.vd.size() == 2);

     

       
953
       
953
       
+
       
    DBGOUT_MIPD__("  Register 2-var connection: " << led);

     

       
954
       
954
       
 
       
    /// Check it's not same 2 vars

     

       
955
       
955
       
 
       
    if (led.vd[0] == led.vd[1]) {

     

       
956
       
956
       
-
       
      MZN_MIPD_assert_soft(

     

       
956
       
956
       
+
       
      MZN_MIPD__assert_soft(

     

       
957
       
957
       
 
       
          0, "MIPD: STRANGE: registering var connection to itself: " << led << ", skipping");

     

       
958
       
958
       
-
       
      MZN_MIPD_ASSERT_FOR_SAT(fabs(led.coefs[0] + led.coefs[1]) < 1e-6,  // TODO param

     

       
959
       
959
       
-
       
                              getEnv()->envi(), led.vd[0]->loc(),

     

       
960
       
960
       
-
       
                              "Var connection to itself seems to indicate UNSAT: " << led);

     

       
958
       
958
       
+
       
      MZN_MIPD__ASSERT_FOR_SAT(fabs(led.coefs[0] + led.coefs[1]) < 1e-6,  // TODO param

     

       
959
       
959
       
+
       
                               getEnv()->envi(), led.vd[0]->loc(),

     

       
960
       
960
       
+
       
                               "Var connection to itself seems to indicate UNSAT: " << led);

     

       
961
       
961
       
 
       
      return;

     

       
962
       
962
       
 
       
    }

     

       
963
       
963
       
 
       
    // register if new variables

     
···

       
975
       
975
       
 
       
        if (nMaybeClq >= 0) {

     

       
976
       
976
       
 
       
          nCliqueAvailable = nMaybeClq;

     

       
977
       
977
       
 
       
        }

     

       
978
       
978
       
-
       
        //           MZN_MIPD_assert_hard( nCliqueAvailable>=0 );

     

       
978
       
978
       
+
       
        //           MZN_MIPD__assert_hard( nCliqueAvailable>=0 );

     

       
979
       
979
       
 
       
        //           fHaveClq[i] = true;

     

       
980
       
980
       
 
       
      }

     

       
981
       
981
       
 
       
    }

     
···

       
991
       
991
       
 
       
      int& nMaybeClq = _vVarDescr[vd->payload()].nClique;

     

       
992
       
992
       
 
       
      if (nMaybeClq >= 0 && nMaybeClq != nCliqueAvailable) {

     

       
993
       
993
       
 
       
        TClique& clqOld = _aCliques[nMaybeClq];

     

       
994
       
994
       
-
       
        MZN_MIPD_assert_hard(clqOld.size());

     

       
994
       
994
       
+
       
        MZN_MIPD__assert_hard(clqOld.size());

     

       
995
       
995
       
 
       
        for (auto& eq2 : clqOld) {

     

       
996
       
996
       
 
       
          for (auto* vd : eq2.vd) {  // point all the variables to the new clique

     

       
997
       
997
       
 
       
            _vVarDescr[vd->payload()].nClique = nCliqueAvailable;

     
···

       
1028
       
1028
       
 
       
        if (this->end() != it1) {

     

       
1029
       
1029
       
 
       
          auto it2 = it1->second.find(*(begV + 1));

     

       
1030
       
1030
       
 
       
          if (it1->second.end() != it2) {

     

       
1031
       
1031
       
-
       
            MZN_MIPD_assert_hard(std::fabs(it2->second.first - A) <

     

       
1032
       
1032
       
-
       
                                 1e-6 * std::max(std::fabs(it2->second.first), std::fabs(A)));

     

       
1033
       
1033
       
-
       
            MZN_MIPD_assert_hard(std::fabs(it2->second.second - B) <

     

       
1034
       
1034
       
-
       
                                 1e-6 * std::max(std::fabs(it2->second.second), std::fabs(B)) +

     

       
1035
       
1035
       
-
       
                                     1e-6);

     

       
1036
       
1036
       
-
       
            MZN_MIPD_assert_hard(std::fabs(A) != 0.0);

     

       
1037
       
1037
       
-
       
            MZN_MIPD_assert_soft(!fVerbose || std::fabs(A) > 1e-12,

     

       
1038
       
1038
       
-
       
                                 " Very small coef: " << (*begV)->id()->str() << " = " << A << " * "

     

       
1039
       
1039
       
-
       
                                                      << (*(begV + 1))->id()->str() << " + " << B);

     

       
1031
       
1031
       
+
       
            MZN_MIPD__assert_hard(std::fabs(it2->second.first - A) <

     

       
1032
       
1032
       
+
       
                                  1e-6 * std::max(std::fabs(it2->second.first), std::fabs(A)));

     

       
1033
       
1033
       
+
       
            MZN_MIPD__assert_hard(std::fabs(it2->second.second - B) <

     

       
1034
       
1034
       
+
       
                                  1e-6 * std::max(std::fabs(it2->second.second), std::fabs(B)) +

     

       
1035
       
1035
       
+
       
                                      1e-6);

     

       
1036
       
1036
       
+
       
            MZN_MIPD__assert_hard(std::fabs(A) != 0.0);

     

       
1037
       
1037
       
+
       
            MZN_MIPD__assert_soft(!fVerbose || std::fabs(A) > 1e-12,

     

       
1038
       
1038
       
+
       
                                  " Very small coef: " << (*begV)->id()->str() << " = " << A

     

       
1039
       
1039
       
+
       
                                                       << " * " << (*(begV + 1))->id()->str()

     

       
1040
       
1040
       
+
       
                                                       << " + " << B);

     

       
1040
       
1041
       
 
       
            if (fReportRepeat) {

     

       
1041
       
1041
       
-
       
              MZN_MIPD_assert_soft(!fVerbose, "LinEqGraph: eqn between "

     

       
1042
       
1042
       
-
       
                                                  << (*begV)->id()->str() << " && "

     

       
1043
       
1043
       
-
       
                                                  << (*(begV + 1))->id()->str()

     

       
1044
       
1044
       
-
       
                                                  << " is repeated. ");

     

       
1042
       
1042
       
+
       
              MZN_MIPD__assert_soft(!fVerbose, "LinEqGraph: eqn between "

     

       
1043
       
1043
       
+
       
                                                   << (*begV)->id()->str() << " && "

     

       
1044
       
1044
       
+
       
                                                   << (*(begV + 1))->id()->str()

     

       
1045
       
1045
       
+
       
                                                   << " is repeated. ");

     

       
1045
       
1046
       
 
       
            }

     

       
1046
       
1047
       
 
       
            return true;

     

       
1047
       
1048
       
 
       
          }

     
···

       
1063
       
1064
       
 
       


     

       
1064
       
1065
       
 
       
      template <class ICoef, class IVarDecl>

     

       
1065
       
1066
       
 
       
      void addArc(ICoef begC, IVarDecl begV, double rhs) {

     

       
1066
       
1066
       
-
       
        MZN_MIPD_assert_soft(!fVerbose || std::fabs(*begC) >= 1e-10,

     

       
1067
       
1067
       
-
       
                             "  Vars " << (*begV)->id()->str() << "  to "

     

       
1068
       
1068
       
-
       
                                       << (*(begV + 1))->id()->str() << ": coef=" << (*begC));

     

       
1067
       
1067
       
+
       
        MZN_MIPD__assert_soft(!fVerbose || std::fabs(*begC) >= 1e-10,

     

       
1068
       
1068
       
+
       
                              "  Vars " << (*begV)->id()->str() << "  to "

     

       
1069
       
1069
       
+
       
                                        << (*(begV + 1))->id()->str() << ": coef=" << (*begC));

     

       
1069
       
1070
       
 
       
        // Transform Ax+By=C into x = -B/Ay+C/A

     

       
1070
       
1071
       
 
       
        const double negBA = -(*(begC + 1)) / (*begC);

     

       
1071
       
1072
       
 
       
        const double CA = rhs / (*begC);

     
···

       
1085
       
1086
       
 
       
      }

     

       
1086
       
1087
       
 
       
      /// Propagate linear relations from the given variable

     

       
1087
       
1088
       
 
       
      void propagate(iterator itStart, TMapVars& mWhereStore) {

     

       
1088
       
1088
       
-
       
        MZN_MIPD_assert_hard(this->end() != itStart);

     

       
1089
       
1089
       
+
       
        MZN_MIPD__assert_hard(this->end() != itStart);

     

       
1089
       
1090
       
 
       
        TMatrixVars mTemp;

     

       
1090
       
1091
       
 
       
        mTemp[itStart->first] = itStart->second;  // init with existing

     

       
1091
       
1092
       
 
       
        DBGOUT_MIPD("Propagation started from " << itStart->first->id()->str() << "  having "

     

       
1092
       
1093
       
 
       
                                                << itStart->second.size() << " connections");

     

       
1093
       
1094
       
 
       
        propagate2(itStart, itStart, std::make_pair(1.0, 0.0), mTemp);

     

       
1094
       
1095
       
 
       
        mWhereStore = mTemp.begin()->second;

     

       
1095
       
1095
       
-
       
        MZN_MIPD_assert_hard_msg(

     

       
1096
       
1096
       
+
       
        MZN_MIPD__assert_hard_msg(

     

       
1096
       
1097
       
 
       
            mWhereStore.size() == this->size() - 1,

     

       
1097
       
1098
       
 
       
            "Variable " << (*(mTemp.begin()->first))

     

       
1098
       
1099
       
 
       
                        << " should be connected to all others in the clique, but "

     
···

       
1121
       
1122
       
 
       
          }

     

       
1122
       
1123
       
 
       
          if (fDive) {

     

       
1123
       
1124
       
 
       
            auto itDST = this->find(itDst->first);

     

       
1124
       
1124
       
-
       
            MZN_MIPD_assert_hard(this->end() != itDST);

     

       
1125
       
1125
       
+
       
            MZN_MIPD__assert_hard(this->end() != itDST);

     

       
1125
       
1126
       
 
       
            propagate2(itSrc, itDST, std::make_pair(A1A2, A1B2plusB1), mWhereStore);

     

       
1126
       
1127
       
 
       
          }

     

       
1127
       
1128
       
 
       
        }

     
···

       
1131
       
1132
       
 
       


     

       
1132
       
1133
       
 
       
    TCliqueSorter(MIPD* pm, int iv) : _mipd(*pm), _iVarStart(iv) {}

     

       
1133
       
1134
       
 
       
    void doRelate() {

     

       
1134
       
1134
       
-
       
      MZN_MIPD_assert_hard(_mipd._vVarDescr[_iVarStart].nClique >= 0);

     

       
1135
       
1135
       
+
       
      MZN_MIPD__assert_hard(_mipd._vVarDescr[_iVarStart].nClique >= 0);

     

       
1135
       
1136
       
 
       
      const TClique& clq = _mipd._aCliques[_mipd._vVarDescr[_iVarStart].nClique];

     

       
1136
       
1137
       
 
       
      for (const auto& eq2 : clq) {

     

       
1137
       
1138
       
 
       
        leg.addEdge(eq2);

     
···

       
1189
       
1190
       
 
       
      cls.mRef1[cls.varRef1] = std::make_pair(1.0, 0.0);

     

       
1190
       
1191
       
 
       


     

       
1191
       
1192
       
 
       
      int iVarRef1 = cls.varRef1->payload();

     

       
1192
       
1192
       
-
       
      MZN_MIPD_assert_hard(nClique == mipd._vVarDescr[iVarRef1].nClique);

     

       
1193
       
1193
       
+
       
      MZN_MIPD__assert_hard(nClique == mipd._vVarDescr[iVarRef1].nClique);

     

       
1193
       
1194
       
 
       
      cls.fRef1HasEqEncode = (mipd._vVarDescr[iVarRef1].pEqEncoding != nullptr);

     

       
1194
       
1195
       
 
       


     

       
1195
       
1196
       
 
       
      // First, construct the domain decomposition in any case

     
···

       
1202
       
1203
       
 
       
      DBGOUT_MIPD("Clique " << nClique << ": main ref var " << cls.varRef1->id()->str()

     

       
1203
       
1204
       
 
       
                            << ", domain dec: " << sDomain);

     

       
1204
       
1205
       
 
       


     

       
1205
       
1205
       
-
       
      MZN_MIPD_ASSERT_FOR_SAT(!sDomain.empty(), mipd.getEnv()->envi(), cls.varRef1->loc(),

     

       
1206
       
1206
       
-
       
                              "clique " << nClique << ": main ref var " << *cls.varRef1->id()

     

       
1207
       
1207
       
-
       
                                        << ", domain decomposition seems empty: " << sDomain);

     

       
1206
       
1206
       
+
       
      MZN_MIPD__ASSERT_FOR_SAT(!sDomain.empty(), mipd.getEnv()->envi(), cls.varRef1->loc(),

     

       
1207
       
1207
       
+
       
                               "clique " << nClique << ": main ref var " << *cls.varRef1->id()

     

       
1208
       
1208
       
+
       
                                         << ", domain decomposition seems empty: " << sDomain);

     

       
1208
       
1209
       
 
       


     

       
1209
       
1209
       
-
       
      MZN_MIPD_FLATTENING_ERROR_IF_NOT(sDomain.checkFiniteBounds(), mipd.getEnv()->envi(),

     

       
1210
       
1210
       
-
       
                                       cls.varRef1->loc(),

     

       
1211
       
1211
       
-
       
                                       "variable " << *cls.varRef1->id()

     

       
1212
       
1212
       
-
       
                                                   << " needs finite bounds for linearisation."

     

       
1213
       
1213
       
-
       
                                                      " Or, use indicator constraints. "

     

       
1214
       
1214
       
-
       
                                                   << "Current domain is " << sDomain);

     

       
1210
       
1210
       
+
       
      MZN_MIPD__FLATTENING_ERROR__IF_NOT(sDomain.checkFiniteBounds(), mipd.getEnv()->envi(),

     

       
1211
       
1211
       
+
       
                                         cls.varRef1->loc(),

     

       
1212
       
1212
       
+
       
                                         "variable " << *cls.varRef1->id()

     

       
1213
       
1213
       
+
       
                                                     << " needs finite bounds for linearisation."

     

       
1214
       
1214
       
+
       
                                                        " Or, use indicator constraints. "

     

       
1215
       
1215
       
+
       
                                                     << "Current domain is " << sDomain);

     

       
1215
       
1216
       
 
       


     

       
1216
       
1216
       
-
       
      MZN_MIPD_assert_hard(sDomain.checkDisjunctStrict());

     

       
1217
       
1217
       
+
       
      MZN_MIPD__assert_hard(sDomain.checkDisjunctStrict());

     

       
1217
       
1218
       
 
       


     

       
1218
       
1219
       
 
       
      makeRangeDomains();

     

       
1219
       
1220
       
 
       


     
···

       
1230
       
1231
       
 
       
      implementPOSTs();

     

       
1231
       
1232
       
 
       


     

       
1232
       
1233
       
 
       
      // Statistics

     

       
1233
       
1233
       
-
       
      if (sDomain.size() < MIPD_stats[N_POSTs_NSubintvMin]) {

     

       
1234
       
1234
       
-
       
        MIPD_stats[N_POSTs_NSubintvMin] = static_cast<double>(sDomain.size());

     

       
1234
       
1234
       
+
       
      if (sDomain.size() < MIPD__stats[N_POSTs__NSubintvMin]) {

     

       
1235
       
1235
       
+
       
        MIPD__stats[N_POSTs__NSubintvMin] = static_cast<double>(sDomain.size());

     

       
1235
       
1236
       
 
       
      }

     

       
1236
       
1236
       
-
       
      MIPD_stats[N_POSTs_NSubintvSum] += sDomain.size();

     

       
1237
       
1237
       
-
       
      if (sDomain.size() > MIPD_stats[N_POSTs_NSubintvMax]) {

     

       
1238
       
1238
       
-
       
        MIPD_stats[N_POSTs_NSubintvMax] = static_cast<double>(sDomain.size());

     

       
1237
       
1237
       
+
       
      MIPD__stats[N_POSTs__NSubintvSum] += sDomain.size();

     

       
1238
       
1238
       
+
       
      if (sDomain.size() > MIPD__stats[N_POSTs__NSubintvMax]) {

     

       
1239
       
1239
       
+
       
        MIPD__stats[N_POSTs__NSubintvMax] = static_cast<double>(sDomain.size());

     

       
1239
       
1240
       
 
       
      }

     

       
1240
       
1241
       
 
       
      for (const auto& intv : sDomain) {

     

       
1241
       
1242
       
 
       
        const auto nSubSize = intv.right - intv.left;

     

       
1242
       
1242
       
-
       
        if (nSubSize < MIPD_stats[N_POSTs_SubSizeMin]) {

     

       
1243
       
1243
       
-
       
          MIPD_stats[N_POSTs_SubSizeMin] = nSubSize;

     

       
1243
       
1243
       
+
       
        if (nSubSize < MIPD__stats[N_POSTs__SubSizeMin]) {

     

       
1244
       
1244
       
+
       
          MIPD__stats[N_POSTs__SubSizeMin] = nSubSize;

     

       
1244
       
1245
       
 
       
        }

     

       
1245
       
1245
       
-
       
        MIPD_stats[N_POSTs_SubSizeSum] += nSubSize;

     

       
1246
       
1246
       
-
       
        if (nSubSize > MIPD_stats[N_POSTs_SubSizeMax]) {

     

       
1247
       
1247
       
-
       
          MIPD_stats[N_POSTs_SubSizeMax] = nSubSize;

     

       
1246
       
1246
       
+
       
        MIPD__stats[N_POSTs__SubSizeSum] += nSubSize;

     

       
1247
       
1247
       
+
       
        if (nSubSize > MIPD__stats[N_POSTs__SubSizeMax]) {

     

       
1248
       
1248
       
+
       
          MIPD__stats[N_POSTs__SubSizeMax] = nSubSize;

     

       
1248
       
1249
       
 
       
        }

     

       
1249
       
1250
       
 
       
      }

     

       
1250
       
1251
       
 
       
      if (cls.fRef1HasEqEncode) {

     

       
1251
       
1251
       
-
       
        ++MIPD_stats[N_POSTs_cliquesWithEqEncode];

     

       
1252
       
1252
       
+
       
        ++MIPD__stats[N_POSTs__cliquesWithEqEncode];

     

       
1252
       
1253
       
 
       
      }

     

       
1253
       
1254
       
 
       
    }

     

       
1254
       
1255
       
 
       


     
···

       
1256
       
1257
       
 
       
    /// Deltas should be scaled but to a minimum of the target's discr

     

       
1257
       
1258
       
 
       
    /// COmparison sense changes on negated vars

     

       
1258
       
1259
       
 
       
    void projectVariableConstr(VarDecl* vd, std::pair<double, double> eq1) {

     

       
1259
       
1259
       
-
       
      DBGOUT_MIPD_FLUSH("  MIPD: projecting variable  ");

     

       
1260
       
1260
       
+
       
      DBGOUT_MIPD__("  MIPD: projecting variable  ");

     

       
1260
       
1261
       
 
       
      DBGOUT_MIPD_SELF(debugprint(vd));

     

       
1261
       
1262
       
 
       
      // Always check if domain becomes empty?         TODO

     

       
1262
       
1263
       
 
       
      const double A = eq1.first;  // vd = A*arg + B.  conversion

     
···

       
1276
       
1277
       
 
       
          lb = bnds.left;

     

       
1277
       
1278
       
 
       
          ub = bnds.right;

     

       
1278
       
1279
       
 
       
        } else {

     

       
1279
       
1279
       
-
       
          MZN_MIPD_FLATTENING_ERROR_IF_NOT(0, mipd.getEnv()->envi(), cls.varRef1->loc(),

     

       
1280
       
1280
       
-
       
                                           "Variable " << vd->id()->str() << " of type "

     

       
1281
       
1281
       
-
       
                                                       << vd->type().toString(mipd._env->envi())

     

       
1282
       
1282
       
-
       
                                                       << " has a domain.");

     

       
1280
       
1280
       
+
       
          MZN_MIPD__FLATTENING_ERROR__IF_NOT(0, mipd.getEnv()->envi(), cls.varRef1->loc(),

     

       
1281
       
1281
       
+
       
                                             "Variable " << vd->id()->str() << " of type "

     

       
1282
       
1282
       
+
       
                                                         << vd->type().toString(mipd._env->envi())

     

       
1283
       
1283
       
+
       
                                                         << " has a domain.");

     

       
1283
       
1284
       
 
       
        }

     

       
1284
       
1285
       
 
       
        //           /// Deleting var domain:

     

       
1285
       
1286
       
 
       
        //           vd->ti()->domain( NULL );

     
···

       
1294
       
1295
       
 
       
      auto& aCalls = mipd._vVarDescr[vd->payload()].aCalls;

     

       
1295
       
1296
       
 
       
      for (Item* pItem : aCalls) {

     

       
1296
       
1297
       
 
       
        auto* pCI = pItem->dynamicCast<ConstraintI>();

     

       
1297
       
1297
       
-
       
        MZN_MIPD_assert_hard(pCI != nullptr);

     

       
1298
       
1298
       
+
       
        MZN_MIPD__assert_hard(pCI != nullptr);

     

       
1298
       
1299
       
 
       
        Call* pCall = pCI->e()->dynamicCast<Call>();

     

       
1299
       
1299
       
-
       
        MZN_MIPD_assert_hard(pCall != nullptr);

     

       
1300
       
1300
       
-
       
        DBGOUT_MIPD_FLUSH("PROPAG CALL  ");

     

       
1300
       
1300
       
+
       
        MZN_MIPD__assert_hard(pCall != nullptr);

     

       
1301
       
1301
       
+
       
        DBGOUT_MIPD__("PROPAG CALL  ");

     

       
1301
       
1302
       
 
       
        DBGOUT_MIPD_SELF(debugprint(pCall));

     

       
1302
       
1303
       
 
       
        // check the bounds for bool in reifs?                     TODO

     

       
1303
       
1304
       
 
       
        auto ipct = mipd._mCallTypes.find(pCall->decl());

     

       
1304
       
1304
       
-
       
        MZN_MIPD_assert_hard(mipd._mCallTypes.end() != ipct);

     

       
1305
       
1305
       
+
       
        MZN_MIPD__assert_hard(mipd._mCallTypes.end() != ipct);

     

       
1305
       
1306
       
 
       
        const DCT& dct = *ipct->second;

     

       
1306
       
1307
       
 
       
        int nCmpType_ADAPTED = dct.nCmpType;

     

       
1307
       
1308
       
 
       
        if (A < 0.0) {                            // negative factor

     
···

       
1315
       
1316
       
 
       
            convertIntSet(pCall->arg(1), SS, cls.varRef1, A, B);

     

       
1316
       
1317
       
 
       
            if (RIT_Static == dct.nReifType) {

     

       
1317
       
1318
       
 
       
              sDomain.intersect(SS);

     

       
1318
       
1318
       
-
       
              ++MIPD_stats[N_POSTs_setIn];

     

       
1319
       
1319
       
+
       
              ++MIPD__stats[N_POSTs__setIn];

     

       
1319
       
1320
       
 
       
            } else {

     

       
1320
       
1321
       
 
       
              sDomain.cutDeltas(SS, std::max(1.0, std::fabs(A)));  // deltas to scale

     

       
1321
       
1321
       
-
       
              ++MIPD_stats[N_POSTs_setInReif];

     

       
1322
       
1322
       
+
       
              ++MIPD__stats[N_POSTs__setInReif];

     

       
1322
       
1323
       
 
       
            }

     

       
1323
       
1324
       
 
       
          } break;

     

       
1324
       
1325
       
 
       
          case CT_Comparison:

     

       
1325
       
1326
       
 
       
            if (RIT_Reif == dct.nReifType) {

     

       
1326
       
1326
       
-
       
              const double rhs = (mipd.aux_float_lt_zero_iff_1_POST == pCall->decl())

     

       
1327
       
1327
       
+
       
              const double rhs = (mipd.aux_float_lt_zero_iff_1__POST == pCall->decl())

     

       
1327
       
1328
       
 
       
                                     ? B /* + A*0.0, relating to 0 */

     

       
1328
       
1329
       
 
       
                                     // The 2nd argument is constant:

     

       
1329
       
1330
       
 
       
                                     : A * MIPD::expr2Const(pCall->arg(1)) + B;

     
···

       
1352
       
1353
       
 
       
                  }

     

       
1353
       
1354
       
 
       
                  break;

     

       
1354
       
1355
       
 
       
                default:

     

       
1355
       
1355
       
-
       
                  MZN_MIPD_assert_hard_msg(0, " No other reified cmp type ");

     

       
1356
       
1356
       
+
       
                  MZN_MIPD__assert_hard_msg(0, " No other reified cmp type ");

     

       
1356
       
1357
       
 
       
              }

     

       
1357
       
1357
       
-
       
              ++MIPD_stats[(vd->ti()->type().isint()) ? N_POSTs_intCmpReif : N_POSTs_floatCmpReif];

     

       
1358
       
1358
       
+
       
              ++MIPD__stats[(vd->ti()->type().isint()) ? N_POSTs__intCmpReif

     

       
1359
       
1359
       
+
       
                                                       : N_POSTs__floatCmpReif];

     

       
1358
       
1360
       
 
       
            } else if (RIT_Static == dct.nReifType) {

     

       
1359
       
1361
       
 
       
              // _ne, later maybe static ineq                                 TODO

     

       
1360
       
1360
       
-
       
              MZN_MIPD_assert_hard(CMPT_NE == dct.nCmpType);

     

       
1362
       
1362
       
+
       
              MZN_MIPD__assert_hard(CMPT_NE == dct.nCmpType);

     

       
1361
       
1363
       
 
       
              const double rhs = A * MIPD::expr2Const(pCall->arg(1)) + B;

     

       
1362
       
1364
       
 
       
              const double rhsRnd = rndIfInt(cls.varRef1, rhs);

     

       
1363
       
1365
       
 
       
              bool fSkipNE = (cls.varRef1->type().isint() && std::fabs(rhs - rhsRnd) > INT_EPS);

     
···

       
1365
       
1367
       
 
       
                const double delta = computeDelta(cls.varRef1, vd, bnds, A, pCall, 2);

     

       
1366
       
1368
       
 
       
                sDomain.cutOut({rhsRnd - delta, rhsRnd + delta});

     

       
1367
       
1369
       
 
       
              }

     

       
1368
       
1368
       
-
       
              ++MIPD_stats[(vd->ti()->type().isint()) ? N_POSTs_intNE : N_POSTs_floatNE];

     

       
1370
       
1370
       
+
       
              ++MIPD__stats[(vd->ti()->type().isint()) ? N_POSTs__intNE : N_POSTs__floatNE];

     

       
1369
       
1371
       
 
       
            } else {  // aux_ relate to 0.0

     

       
1370
       
1372
       
 
       
                      // But we don't modify domain splitting for them currently

     

       
1371
       
1371
       
-
       
              ++MIPD_stats[(vd->ti()->type().isint()) ? N_POSTs_intAux : N_POSTs_floatAux];

     

       
1372
       
1372
       
-
       
              MZN_MIPD_assert_hard(RIT_Halfreif == dct.nReifType);

     

       
1373
       
1373
       
+
       
              ++MIPD__stats[(vd->ti()->type().isint()) ? N_POSTs__intAux : N_POSTs__floatAux];

     

       
1374
       
1374
       
+
       
              MZN_MIPD__assert_hard(RIT_Halfreif == dct.nReifType);

     

       
1373
       
1375
       
 
       
              //                 const double rhs = B;               // + A*0

     

       
1374
       
1376
       
 
       
              //                 const double delta = vd->type().isint() ? 1.0 : 1e-5;           //

     

       
1375
       
1377
       
 
       
              //                 TODO : eps

     
···

       
1377
       
1379
       
 
       
            break;

     

       
1378
       
1380
       
 
       
          case CT_Encode:

     

       
1379
       
1381
       
 
       
            // See if any further constraints here?                             TODO

     

       
1380
       
1380
       
-
       
            ++MIPD_stats[N_POSTs_eq_encode];

     

       
1382
       
1382
       
+
       
            ++MIPD__stats[N_POSTs__eq_encode];

     

       
1381
       
1383
       
 
       
            break;

     

       
1382
       
1384
       
 
       
          default:

     

       
1383
       
1383
       
-
       
            MZN_MIPD_assert_hard_msg(0, "Unknown constraint type");

     

       
1385
       
1385
       
+
       
            MZN_MIPD__assert_hard_msg(0, "Unknown constraint type");

     

       
1384
       
1386
       
 
       
        }

     

       
1385
       
1387
       
 
       
      }

     

       
1386
       
1388
       
 
       
      DBGOUT_MIPD(" Clique domain after proj of " << A << " * " << vd->id()->str() << " + " << B

     
···

       
1412
       
1414
       
 
       
        double lb0 = (bnds.left - iRef1.second.second) / iRef1.second.first;

     

       
1413
       
1415
       
 
       
        double ub0 = (bnds.right - iRef1.second.second) / iRef1.second.first;

     

       
1414
       
1416
       
 
       
        if (lb0 > ub0) {

     

       
1415
       
1415
       
-
       
          MZN_MIPD_assert_hard(iRef1.second.first < 0.0);

     

       
1417
       
1417
       
+
       
          MZN_MIPD__assert_hard(iRef1.second.first < 0.0);

     

       
1416
       
1418
       
 
       
          std::swap(lb0, ub0);

     

       
1417
       
1419
       
 
       
        }

     

       
1418
       
1420
       
 
       
        if (vd->type().isint()) {

     
···

       
1433
       
1435
       
 
       
      const long long iMin = mipd.expr2ExprArray(

     

       
1434
       
1436
       
 
       
          mipd._vVarDescr[cls.varRef1->payload()].pEqEncoding->e()->dynamicCast<Call>()->arg(1),

     

       
1435
       
1437
       
 
       
          pp);

     

       
1436
       
1436
       
-
       
      MZN_MIPD_assert_hard(pp.size() >= bnds.right - bnds.left + 1);

     

       
1437
       
1437
       
-
       
      MZN_MIPD_assert_hard(iMin <= bnds.left);

     

       
1438
       
1438
       
+
       
      MZN_MIPD__assert_hard(pp.size() >= bnds.right - bnds.left + 1);

     

       
1439
       
1439
       
+
       
      MZN_MIPD__assert_hard(iMin <= bnds.left);

     

       
1438
       
1440
       
 
       
      long long vEE = iMin;

     

       
1439
       
1439
       
-
       
      DBGOUT_MIPD_FLUSH(

     

       
1441
       
1441
       
+
       
      DBGOUT_MIPD__(

     

       
1440
       
1442
       
 
       
          "   SYNC EQ_ENCODE( "

     

       
1441
       
1443
       
 
       
          << (*cls.varRef1) << ",   bitflags: "

     

       
1442
       
1444
       
 
       
          << *(mipd._vVarDescr[cls.varRef1->payload()].pEqEncoding->e()->dynamicCast<Call>()->arg(

     
···

       
1449
       
1451
       
 
       
          }

     

       
1450
       
1452
       
 
       
          if (pp[vEE - iMin]->isa<Id>()) {

     

       
1451
       
1453
       
 
       
            if (pp[vEE - iMin]->dynamicCast<Id>()->decl()->type().isvar()) {

     

       
1452
       
1452
       
-
       
              DBGOUT_MIPD_FLUSH(vEE << ", ");

     

       
1454
       
1454
       
+
       
              DBGOUT_MIPD__(vEE << ", ");

     

       
1453
       
1455
       
 
       
              setVarDomain(pp[vEE - iMin]->dynamicCast<Id>()->decl(), 0.0, 0.0);

     

       
1454
       
1456
       
 
       
            }

     

       
1455
       
1457
       
 
       
          }

     
···

       
1459
       
1461
       
 
       
      for (; vEE < static_cast<long long>(iMin + pp.size()); ++vEE) {

     

       
1460
       
1462
       
 
       
        if (pp[vEE - iMin]->isa<Id>()) {

     

       
1461
       
1463
       
 
       
          if (pp[vEE - iMin]->dynamicCast<Id>()->decl()->type().isvar()) {

     

       
1462
       
1462
       
-
       
            DBGOUT_MIPD_FLUSH(vEE << ", ");

     

       
1464
       
1464
       
+
       
            DBGOUT_MIPD__(vEE << ", ");

     

       
1463
       
1465
       
 
       
            setVarDomain(pp[vEE - iMin]->dynamicCast<Id>()->decl(), 0.0, 0.0);

     

       
1464
       
1466
       
 
       
          }

     

       
1465
       
1467
       
 
       
        }

     
···

       
1480
       
1482
       
 
       
        if (sDomain.maxInterval() <= mipd.nMaxIntv2Bits ||

     

       
1481
       
1483
       
 
       
            sDomain.cardInt() <= mipd.dMaxNValueDensity * sDomain.size()) {

     

       
1482
       
1484
       
 
       
          sDomain.split2Bits();

     

       
1483
       
1483
       
-
       
          ++MIPD_stats[N_POSTs_clEEEnforced];

     

       
1485
       
1485
       
+
       
          ++MIPD__stats[N_POSTs__clEEEnforced];

     

       
1484
       
1486
       
 
       
        }

     

       
1485
       
1487
       
 
       
      }

     

       
1486
       
1488
       
 
       
    }

     
···

       
1490
       
1492
       
 
       
    void createDomainFlags() {

     

       
1491
       
1493
       
 
       
      std::vector<Expression*> vVars(sDomain.size());  // flags for each subinterval

     

       
1492
       
1494
       
 
       
      std::vector<double> vIntvLB(sDomain.size() + 1);

     

       
1493
       
1493
       
-
       
      std::vector<double> vIntvUB_(sDomain.size() + 1);

     

       
1495
       
1495
       
+
       
      std::vector<double> vIntvUB__(sDomain.size() + 1);

     

       
1494
       
1496
       
 
       
      int i = 0;

     

       
1495
       
1497
       
 
       
      double dMaxIntv = -1.0;

     

       
1496
       
1498
       
 
       
      for (const auto& intv : sDomain) {

     

       
1497
       
1499
       
 
       
        intv.varFlag = addIntVar(0.0, 1.0);

     

       
1498
       
1500
       
 
       
        vVars[i] = intv.varFlag->id();

     

       
1499
       
1501
       
 
       
        vIntvLB[i] = intv.left;

     

       
1500
       
1500
       
-
       
        vIntvUB_[i] = -intv.right;

     

       
1502
       
1502
       
+
       
        vIntvUB__[i] = -intv.right;

     

       
1501
       
1503
       
 
       
        dMaxIntv = std::max(dMaxIntv, intv.right - intv.left);

     

       
1502
       
1504
       
 
       
        ++i;

     

       
1503
       
1505
       
 
       
      }

     
···

       
1509
       
1511
       
 
       
      vIntvLB[i] = -1.0;  // var1 >= sum(LBi*flagi)

     

       
1510
       
1512
       
 
       
      /// STRICT equality encoding if small intervals

     

       
1511
       
1513
       
 
       
      if (dMaxIntv > 1e-6) {  // EPS = param?   TODO

     

       
1512
       
1512
       
-
       
        vIntvUB_[i] = 1.0;    // var1 <= sum(UBi*flagi)

     

       
1514
       
1514
       
+
       
        vIntvUB__[i] = 1.0;   // var1 <= sum(UBi*flagi)

     

       
1513
       
1515
       
 
       
        addLinConstr(vIntvLB, vVars, CMPT_LE, 0.0);

     

       
1514
       
1514
       
-
       
        addLinConstr(vIntvUB_, vVars, CMPT_LE, 0.0);

     

       
1516
       
1516
       
+
       
        addLinConstr(vIntvUB__, vVars, CMPT_LE, 0.0);

     

       
1515
       
1517
       
 
       
      } else {

     

       
1516
       
1516
       
-
       
        ++MIPD_stats[N_POSTs_clEEFound];

     

       
1518
       
1518
       
+
       
        ++MIPD__stats[N_POSTs__clEEFound];

     

       
1517
       
1519
       
 
       
        addLinConstr(vIntvLB, vVars, CMPT_EQ, 0.0);

     

       
1518
       
1520
       
 
       
      }

     

       
1519
       
1521
       
 
       
    }

     
···

       
1522
       
1524
       
 
       
    void implementPOSTs() {

     

       
1523
       
1525
       
 
       
      auto bnds = sDomain.getBounds();

     

       
1524
       
1526
       
 
       
      for (auto& iRef1 : cls.mRef1) {

     

       
1525
       
1525
       
-
       
        //           DBGOUT_MIPD_FLUSH( "  MIPD: implementing constraints of variable  " );

     

       
1527
       
1527
       
+
       
        //           DBGOUT_MIPD__( "  MIPD: implementing constraints of variable  " );

     

       
1526
       
1528
       
 
       
        //           DBGOUT_MIPD_SELF( debugprint(vd) );

     

       
1527
       
1529
       
 
       
        VarDecl* vd = iRef1.first;

     

       
1528
       
1530
       
 
       
        auto eq1 = iRef1.second;

     
···

       
1532
       
1534
       
 
       
        auto& aCalls = mipd._vVarDescr[vd->payload()].aCalls;

     

       
1533
       
1535
       
 
       
        for (Item* pItem : aCalls) {

     

       
1534
       
1536
       
 
       
          auto* pCI = pItem->dynamicCast<ConstraintI>();

     

       
1535
       
1535
       
-
       
          MZN_MIPD_assert_hard(pCI);

     

       
1537
       
1537
       
+
       
          MZN_MIPD__assert_hard(pCI);

     

       
1536
       
1538
       
 
       
          Call* pCall = pCI->e()->dynamicCast<Call>();

     

       
1537
       
1537
       
-
       
          MZN_MIPD_assert_hard(pCall);

     

       
1538
       
1538
       
-
       
          DBGOUT_MIPD_FLUSH("IMPL CALL  ");

     

       
1539
       
1539
       
+
       
          MZN_MIPD__assert_hard(pCall);

     

       
1540
       
1540
       
+
       
          DBGOUT_MIPD__("IMPL CALL  ");

     

       
1539
       
1541
       
 
       
          DBGOUT_MIPD_SELF(debugprint(pCall));

     

       
1540
       
1542
       
 
       
          // check the bounds for bool in reifs?                     TODO

     

       
1541
       
1543
       
 
       
          auto ipct = mipd._mCallTypes.find(pCall->decl());

     

       
1542
       
1542
       
-
       
          MZN_MIPD_assert_hard(mipd._mCallTypes.end() != ipct);

     

       
1544
       
1544
       
+
       
          MZN_MIPD__assert_hard(mipd._mCallTypes.end() != ipct);

     

       
1543
       
1545
       
 
       
          const DCT& dct = *ipct->second;

     

       
1544
       
1546
       
 
       
          int nCmpType_ADAPTED = dct.nCmpType;

     

       
1545
       
1547
       
 
       
          if (A < 0.0) {                            // negative factor

     
···

       
1557
       
1559
       
 
       
              break;

     

       
1558
       
1560
       
 
       
            case CT_Comparison:

     

       
1559
       
1561
       
 
       
              if (RIT_Reif == dct.nReifType) {

     

       
1560
       
1560
       
-
       
                const double rhs = (mipd.aux_float_lt_zero_iff_1_POST == pCall->decl())

     

       
1562
       
1562
       
+
       
                const double rhs = (mipd.aux_float_lt_zero_iff_1__POST == pCall->decl())

     

       
1561
       
1563
       
 
       
                                       ? B /* + A*0.0, relating to 0 */

     

       
1562
       
1564
       
 
       
                                       // The 2nd argument is constant:

     

       
1563
       
1565
       
 
       
                                       : A * MIPD::expr2Const(pCall->arg(1)) + B;

     
···

       
1588
       
1590
       
 
       
                }

     

       
1589
       
1591
       
 
       
              } else if (RIT_Static == dct.nReifType) {

     

       
1590
       
1592
       
 
       
                // !hing here for NE

     

       
1591
       
1591
       
-
       
                MZN_MIPD_assert_hard(CMPT_NE == nCmpType_ADAPTED);

     

       
1593
       
1593
       
+
       
                MZN_MIPD__assert_hard(CMPT_NE == nCmpType_ADAPTED);

     

       
1592
       
1594
       
 
       
              } else {  // aux_ relate to 0.0

     

       
1593
       
1595
       
 
       
                        // But we don't modify domain splitting for them currently

     

       
1594
       
1594
       
-
       
                MZN_MIPD_assert_hard(RIT_Halfreif == dct.nReifType);

     

       
1596
       
1596
       
+
       
                MZN_MIPD__assert_hard(RIT_Halfreif == dct.nReifType);

     

       
1595
       
1597
       
 
       
                double rhs = B;  // + A*0

     

       
1596
       
1598
       
 
       
                const double rhsUp = rndUpIfInt(cls.varRef1, rhs);

     

       
1597
       
1599
       
 
       
                const double rhsDown = rndDownIfInt(cls.varRef1, rhs);

     

       
1598
       
1600
       
 
       
                const double rhsRnd = rndIfInt(cls.varRef1, rhs);

     

       
1599
       
1601
       
 
       
                double delta = 0.0;

     

       
1600
       
1600
       
-
       
                if (mipd.aux_float_lt_zero_if_1_POST == pCall->decl()) {  // only float && lt

     

       
1602
       
1602
       
+
       
                if (mipd.aux_float_lt_zero_if_1__POST == pCall->decl()) {  // only float && lt

     

       
1601
       
1603
       
 
       
                  delta = computeDelta(cls.varRef1, vd, bnds, A, pCall, 3);

     

       
1602
       
1604
       
 
       
                }

     

       
1603
       
1605
       
 
       
                if (nCmpType_ADAPTED < 0) {

     
···

       
1645
       
1647
       
 
       
                      fUseDD = !fInner;

     

       
1646
       
1648
       
 
       
                    } break;

     

       
1647
       
1649
       
 
       
                    default:

     

       
1648
       
1648
       
-
       
                      MZN_MIPD_assert_hard_msg(0, "Unknown halfreif cmp type");

     

       
1650
       
1650
       
+
       
                      MZN_MIPD__assert_hard_msg(0, "Unknown halfreif cmp type");

     

       
1649
       
1651
       
 
       
                  }

     

       
1650
       
1652
       
 
       
                }

     

       
1651
       
1653
       
 
       
                if (fUseDD) {  // use sDomain

     
···

       
1666
       
1668
       
 
       
                      cls.varRef1->ti()->type().isint()

     

       
1667
       
1669
       
 
       
                          ? 1

     

       
1668
       
1670
       
 
       
                          : 2;  // need the type of the variable to be constr

     

       
1669
       
1669
       
-
       
                  MZN_MIPD_assert_hard(static_cast<unsigned int>(nIdxInd) < pCall->argCount());

     

       
1671
       
1671
       
+
       
                  MZN_MIPD__assert_hard(static_cast<unsigned int>(nIdxInd) < pCall->argCount());

     

       
1670
       
1672
       
 
       
                  Expression* pInd = pCall->arg(nIdxInd);

     

       
1671
       
1673
       
 
       
                  if (fLE && rhs < bnds.right) {

     

       
1672
       
1674
       
 
       
                    if (rhs >= bnds.left) {

     
···

       
1694
       
1696
       
 
       
              // See if any further constraints here?                             TODO

     

       
1695
       
1697
       
 
       
              break;

     

       
1696
       
1698
       
 
       
            default:

     

       
1697
       
1697
       
-
       
              MZN_MIPD_assert_hard_msg(0, "Unknown constraint type");

     

       
1699
       
1699
       
+
       
              MZN_MIPD__assert_hard_msg(0, "Unknown constraint type");

     

       
1698
       
1700
       
 
       
          }

     

       
1699
       
1701
       
 
       
          pItem->remove();  // removing the call

     

       
1700
       
1702
       
 
       
        }

     
···

       
1707
       
1709
       
 
       


     

       
1708
       
1710
       
 
       
    /// sets varFlag = || <= sum( intv.varFlag : SS )

     

       
1709
       
1711
       
 
       
    void relateReifFlag(Expression* expFlag, const SetOfIntvReal& SS, EnumReifType nRT = RIT_Reif) {

     

       
1710
       
1710
       
-
       
      MZN_MIPD_assert_hard(RIT_Reif == nRT || RIT_Halfreif == nRT);

     

       
1711
       
1711
       
-
       
      //         MZN_MIPD_assert_hard( sDomain.size()>=2 );

     

       
1712
       
1712
       
+
       
      MZN_MIPD__assert_hard(RIT_Reif == nRT || RIT_Halfreif == nRT);

     

       
1713
       
1713
       
+
       
      //         MZN_MIPD__assert_hard( sDomain.size()>=2 );

     

       
1712
       
1714
       
 
       
      VarDecl* varFlag = MIPD::expr2VarDecl(expFlag);

     

       
1713
       
1715
       
 
       
      std::vector<Expression*> vIntvFlags;

     

       
1714
       
1716
       
 
       
      if (cls.fRef1HasEqEncode) {  // use eq_encoding

     

       
1715
       
1715
       
-
       
        MZN_MIPD_assert_hard(varFlag->type().isint());

     

       
1717
       
1717
       
+
       
        MZN_MIPD__assert_hard(varFlag->type().isint());

     

       
1716
       
1718
       
 
       
        std::vector<Expression*> pp;

     

       
1717
       
1719
       
 
       
        auto bnds = sDomain.getBounds();

     

       
1718
       
1720
       
 
       
        const long long iMin = mipd.expr2ExprArray(

     

       
1719
       
1721
       
 
       
            mipd._vVarDescr[cls.varRef1->payload()].pEqEncoding->e()->dynamicCast<Call>()->arg(1),

     

       
1720
       
1722
       
 
       
            pp);

     

       
1721
       
1721
       
-
       
        MZN_MIPD_assert_hard(pp.size() >= bnds.right - bnds.left + 1);

     

       
1722
       
1722
       
-
       
        MZN_MIPD_assert_hard(iMin <= bnds.left);

     

       
1723
       
1723
       
+
       
        MZN_MIPD__assert_hard(pp.size() >= bnds.right - bnds.left + 1);

     

       
1724
       
1724
       
+
       
        MZN_MIPD__assert_hard(iMin <= bnds.left);

     

       
1723
       
1725
       
 
       
        for (const auto& intv : SS) {

     

       
1724
       
1726
       
 
       
          for (long long vv = (long long)std::max(double(iMin), ceil(intv.left));

     

       
1725
       
1727
       
 
       
               vv <= (long long)std::min(double(iMin) + pp.size() - 1, floor(intv.right)); ++vv) {

     
···

       
1727
       
1729
       
 
       
          }

     

       
1728
       
1730
       
 
       
        }

     

       
1729
       
1731
       
 
       
      } else {

     

       
1730
       
1730
       
-
       
        MZN_MIPD_assert_hard(varFlag->type().isint());

     

       
1732
       
1732
       
+
       
        MZN_MIPD__assert_hard(varFlag->type().isint());

     

       
1731
       
1733
       
 
       
        for (const auto& intv : SS) {

     

       
1732
       
1734
       
 
       
          auto it1 = sDomain.lower_bound(intv.left);

     

       
1733
       
1735
       
 
       
          auto it2 = sDomain.upper_bound(intv.right);

     
···

       
1735
       
1737
       
 
       
          // Check that we are looking ! into a subinterval:

     

       
1736
       
1738
       
 
       
          if (sDomain.begin() != it11) {

     

       
1737
       
1739
       
 
       
            --it11;

     

       
1738
       
1738
       
-
       
            MZN_MIPD_assert_hard(it11->right < intv.left);

     

       
1740
       
1740
       
+
       
            MZN_MIPD__assert_hard(it11->right < intv.left);

     

       
1739
       
1741
       
 
       
          }

     

       
1740
       
1742
       
 
       
          auto it12 = it2;

     

       
1741
       
1743
       
 
       
          if (sDomain.begin() != it12) {

     

       
1742
       
1744
       
 
       
            --it12;

     

       
1743
       
1743
       
-
       
            MZN_MIPD_assert_hard_msg(it12->right <= intv.right,

     

       
1744
       
1744
       
-
       
                                     "  relateReifFlag for " << intv << " in " << sDomain);

     

       
1745
       
1745
       
+
       
            MZN_MIPD__assert_hard_msg(it12->right <= intv.right,

     

       
1746
       
1746
       
+
       
                                      "  relateReifFlag for " << intv << " in " << sDomain);

     

       
1745
       
1747
       
 
       
          }

     

       
1746
       
1748
       
 
       
          for (it12 = it1; it12 != it2; ++it12) {

     

       
1747
       
1749
       
 
       
            if (it12->varFlag != nullptr) {

     

       
1748
       
1750
       
 
       
              vIntvFlags.push_back(it12->varFlag->id());

     

       
1749
       
1751
       
 
       
            } else {

     

       
1750
       
1750
       
-
       
              MZN_MIPD_assert_hard(1 == sDomain.size());

     

       
1752
       
1752
       
+
       
              MZN_MIPD__assert_hard(1 == sDomain.size());

     

       
1751
       
1753
       
 
       
              vIntvFlags.push_back(IntLit::a(1));  // just a constant then

     

       
1752
       
1754
       
 
       
            }

     

       
1753
       
1755
       
 
       
          }

     
···

       
1782
       
1784
       
 
       
        //           nti->domain(newDom);

     

       
1783
       
1785
       
 
       
        vd->ti()->domain(newDom);

     

       
1784
       
1786
       
 
       
      } else {

     

       
1785
       
1785
       
-
       
        MZN_MIPD_assert_hard_msg(0, "Unknown var type ");

     

       
1787
       
1787
       
+
       
        MZN_MIPD__assert_hard_msg(0, "Unknown var type ");

     

       
1786
       
1788
       
 
       
      }

     

       
1787
       
1789
       
 
       
    }

     

       
1788
       
1790
       
 
       


     
···

       
1802
       
1804
       
 
       
    void addLinConstr(std::vector<double>& coefs, std::vector<Expression*>& vars,

     

       
1803
       
1805
       
 
       
                      EnumCmpType nCmpType, double rhs) {

     

       
1804
       
1806
       
 
       
      std::vector<Expression*> args(3);

     

       
1805
       
1805
       
-
       
      MZN_MIPD_assert_hard(vars.size() >= 2);

     

       
1807
       
1807
       
+
       
      MZN_MIPD__assert_hard(vars.size() >= 2);

     

       
1806
       
1808
       
 
       
      for (auto* v : vars) {

     

       
1807
       
1807
       
-
       
        MZN_MIPD_assert_hard(&v);

     

       
1809
       
1809
       
+
       
        MZN_MIPD__assert_hard(&v);

     

       
1808
       
1810
       
 
       
        //             throw std::string("addLinConstr: &var=NULL");

     

       
1809
       
1809
       
-
       
        MZN_MIPD_assert_hard_msg(v->isa<Id>() || v->isa<IntLit>() || v->isa<FloatLit>(),

     

       
1810
       
1810
       
-
       
                                 "  expression at " << (&v) << " eid = " << v->eid()

     

       
1811
       
1811
       
-
       
                                                    << " while E_INTLIT=" << Expression::E_INTLIT);

     

       
1811
       
1811
       
+
       
        MZN_MIPD__assert_hard_msg(v->isa<Id>() || v->isa<IntLit>() || v->isa<FloatLit>(),

     

       
1812
       
1812
       
+
       
                                  "  expression at " << (&v) << " eid = " << v->eid()

     

       
1813
       
1813
       
+
       
                                                     << " while E_INTLIT=" << Expression::E_INTLIT);

     

       
1812
       
1814
       
 
       
        //             throw std::string("addLinConstr: only id's as variables allowed");

     

       
1813
       
1815
       
 
       
      }

     

       
1814
       
1814
       
-
       
      MZN_MIPD_assert_hard(coefs.size() == vars.size());

     

       
1815
       
1815
       
-
       
      MZN_MIPD_assert_hard(CMPT_EQ == nCmpType || CMPT_LE == nCmpType);

     

       
1816
       
1816
       
+
       
      MZN_MIPD__assert_hard(coefs.size() == vars.size());

     

       
1817
       
1817
       
+
       
      MZN_MIPD__assert_hard(CMPT_EQ == nCmpType || CMPT_LE == nCmpType);

     

       
1816
       
1818
       
 
       
      DBGOUT_MIPD_SELF(  // LinEq leq; leq.coefs=coefs; leq.vd=vars; leq.rhs=rhs;

     

       
1817
       
1817
       
-
       
          DBGOUT_MIPD_FLUSH(" ADDING " << (CMPT_EQ == nCmpType ? "LIN_EQ" : "LIN_LE") << ": [ ");

     

       
1819
       
1819
       
+
       
          DBGOUT_MIPD__(" ADDING " << (CMPT_EQ == nCmpType ? "LIN_EQ" : "LIN_LE") << ": [ ");

     

       
1818
       
1820
       
 
       
          for (auto c

     

       
1819
       
1819
       
-
       
               : coefs) DBGOUT_MIPD_FLUSH(c << ',');

     

       
1820
       
1820
       
-
       
          DBGOUT_MIPD_FLUSH(" ] * [ "); for (auto v

     

       
1821
       
1821
       
-
       
                                             : vars) {

     

       
1822
       
1822
       
-
       
            MZN_MIPD_assert_hard(!v->isa<VarDecl>());

     

       
1823
       
1823
       
-
       
            if (v->isa<Id>()) DBGOUT_MIPD_FLUSH(v->dynamicCast<Id>()->str() << ',');

     

       
1821
       
1821
       
+
       
               : coefs) DBGOUT_MIPD__(c << ',');

     

       
1822
       
1822
       
+
       
          DBGOUT_MIPD__(" ] * [ "); for (auto v

     

       
1823
       
1823
       
+
       
                                         : vars) {

     

       
1824
       
1824
       
+
       
            MZN_MIPD__assert_hard(!v->isa<VarDecl>());

     

       
1825
       
1825
       
+
       
            if (v->isa<Id>()) DBGOUT_MIPD__(v->dynamicCast<Id>()->str() << ',');

     

       
1824
       
1826
       
 
       
            //             else if ( v->isa<VarDecl>() )

     

       
1825
       
1825
       
-
       
            //               MZN_MIPD_assert_hard ("addLinConstr: only id's as variables allowed");

     

       
1827
       
1827
       
+
       
            //               MZN_MIPD__assert_hard ("addLinConstr: only id's as variables allowed");

     

       
1826
       
1828
       
 
       
            else

     

       
1827
       
1827
       
-
       
              DBGOUT_MIPD_FLUSH(mipd.expr2Const(v) << ',');

     

       
1829
       
1829
       
+
       
              DBGOUT_MIPD__(mipd.expr2Const(v) << ',');

     

       
1828
       
1830
       
 
       
          } DBGOUT_MIPD(" ] " << (CMPT_EQ == nCmpType ? "== " : "<= ") << rhs););

     

       
1829
       
1831
       
 
       
      std::vector<Expression*> nc_c;

     

       
1830
       
1832
       
 
       
      std::vector<Expression*> nx;

     
···

       
1837
       
1839
       
 
       
      }

     

       
1838
       
1840
       
 
       
      auto sName = constants().ids.float_.lin_eq;  // "int_lin_eq";

     

       
1839
       
1841
       
 
       
      FunctionI* fDecl = mipd.float_lin_eq;

     

       
1840
       
1840
       
-
       
      if (fFloat) {  // MZN_MIPD_assert_hard all vars of same type     TODO

     

       
1842
       
1842
       
+
       
      if (fFloat) {  // MZN_MIPD__assert_hard all vars of same type     TODO

     

       
1841
       
1843
       
 
       
        for (int i = 0; i < vars.size(); ++i) {

     

       
1842
       
1844
       
 
       
          if (fabs(coefs[i]) > 1e-8)  /// Only add terms with non-0 coefs. TODO Eps=param

     

       
1843
       
1845
       
 
       
          {

     
···

       
1888
       
1890
       
 
       
        }

     

       
1889
       
1891
       
 
       
      }

     

       
1890
       
1892
       
 
       
      if (mipd.getEnv()->envi().cseMapEnd() != mipd.getEnv()->envi().cseMapFind(args[0])) {

     

       
1891
       
1891
       
-
       
        DBGOUT_MIPD_FLUSH(" Found expr ");

     

       
1893
       
1893
       
+
       
        DBGOUT_MIPD__(" Found expr ");

     

       
1892
       
1894
       
 
       
        DBGOUT_MIPD_SELF(debugprint(args[0]));

     

       
1893
       
1895
       
 
       
      }

     

       
1894
       
1896
       
 
       
      auto* nc = new Call(Location().introduce(), ASTString(sName), args);

     
···

       
1899
       
1901
       
 
       


     

       
1900
       
1902
       
 
       
    /// domain / reif set of one variable into that for a!her

     

       
1901
       
1903
       
 
       
    void convertIntSet(Expression* e, SetOfIntvReal& s, VarDecl* varTarget, double A, double B) {

     

       
1902
       
1902
       
-
       
      MZN_MIPD_assert_hard(A != 0.0);

     

       
1904
       
1904
       
+
       
      MZN_MIPD__assert_hard(A != 0.0);

     

       
1903
       
1905
       
 
       
      if (e->type().isIntSet()) {

     

       
1904
       
1906
       
 
       
        IntSetVal* S = eval_intset(mipd.getEnv()->envi(), e);

     

       
1905
       
1907
       
 
       
        IntSetRanges domr(S);

     
···

       
1949
       
1951
       
 
       
  };  // class DomainDecomp

     

       
1950
       
1952
       
 
       


     

       
1951
       
1953
       
 
       
  /// Vars without explicit clique still need a decomposition.

     

       
1952
       
1952
       
-
       
  /// Have !iced all _POSTs, set_in's && eq_encode's to it BEFORE

     

       
1954
       
1954
       
+
       
  /// Have !iced all __POSTs, set_in's && eq_encode's to it BEFORE

     

       
1953
       
1955
       
 
       
  /// In each clique, relate all vars to one chosen

     

       
1954
       
1956
       
 
       
  /// Find all "smallest rel. factor" variables, integer && with eq_encode if avail

     

       
1955
       
1957
       
 
       
  /// Re-relate all vars to it

     

       
1956
       
1956
       
-
       
  /// Refer all _POSTs && dom() to it

     

       
1958
       
1958
       
+
       
  /// Refer all __POSTs && dom() to it

     

       
1957
       
1959
       
 
       
  /// build domain decomposition

     

       
1958
       
1960
       
 
       
  /// Implement all domain constraints, incl. possible corresp, of eq_encode's

     

       
1959
       
1961
       
 
       
  ///

     
···

       
1975
       
1977
       
 
       
        _vVarDescr[iVar].fDomainConstrProcessed = 1U;

     

       
1976
       
1978
       
 
       
      }

     

       
1977
       
1979
       
 
       
    }

     

       
1978
       
1978
       
-
       
    // Clean up _POSTs:

     

       
1980
       
1980
       
+
       
    // Clean up __POSTs:

     

       
1979
       
1981
       
 
       
    for (auto& vVar : _vVarDescr) {

     

       
1980
       
1982
       
 
       
      for (auto* pCallI : vVar.aCalls) {

     

       
1981
       
1983
       
 
       
        pCallI->remove();

     
···

       
1991
       
1993
       
 
       
    // The requirement to have actual variable objects

     

       
1992
       
1994
       
 
       
    // might be a limitation if more optimizations are done before...

     

       
1993
       
1995
       
 
       
    // Might need to flexibilize this                       TODO

     

       
1994
       
1994
       
-
       
    //       MZN_MIPD_assert_hard_msg( ! arg->dynamicCast<IntLit>(),

     

       
1996
       
1996
       
+
       
    //       MZN_MIPD__assert_hard_msg( ! arg->dynamicCast<IntLit>(),

     

       
1995
       
1997
       
 
       
    //                                  "Expression " << *arg << " is an IntLit!" );

     

       
1996
       
1996
       
-
       
    //       MZN_MIPD_assert_hard( ! arg->dynamicCast<FloatLit>() );

     

       
1997
       
1997
       
-
       
    //       MZN_MIPD_assert_hard( ! arg->dynamicCast<BoolLit>() );

     

       
1998
       
1998
       
+
       
    //       MZN_MIPD__assert_hard( ! arg->dynamicCast<FloatLit>() );

     

       
1999
       
1999
       
+
       
    //       MZN_MIPD__assert_hard( ! arg->dynamicCast<BoolLit>() );

     

       
1998
       
2000
       
 
       
    Id* id = arg->dynamicCast<Id>();

     

       
1999
       
1999
       
-
       
    //       MZN_MIPD_assert_hard(id);

     

       
2001
       
2001
       
+
       
    //       MZN_MIPD__assert_hard(id);

     

       
2000
       
2002
       
 
       
    if (nullptr == id) {

     

       
2001
       
2003
       
 
       
      return nullptr;  // the call using this should be ignored?

     

       
2002
       
2004
       
 
       
    }

     

       
2003
       
2005
       
 
       
    VarDecl* vd = id->decl();

     

       
2004
       
2004
       
-
       
    MZN_MIPD_assert_hard(vd);

     

       
2006
       
2006
       
+
       
    MZN_MIPD__assert_hard(vd);

     

       
2005
       
2007
       
 
       
    return vd;

     

       
2006
       
2008
       
 
       
  }

     

       
2007
       
2009
       
 
       


     
···

       
2037
       
2039
       
 
       
    if (auto* bl = arg->dynamicCast<BoolLit>()) {

     

       
2038
       
2040
       
 
       
      return static_cast<double>(bl->v());

     

       
2039
       
2041
       
 
       
    }

     

       
2040
       
2040
       
-
       
    MZN_MIPD_assert_hard_msg(0, "unexpected expression instead of an int/float/bool literal: eid="

     

       
2041
       
2041
       
-
       
                                    << arg->eid() << " while E_INTLIT=" << Expression::E_INTLIT);

     

       
2042
       
2042
       
+
       
    MZN_MIPD__assert_hard_msg(0, "unexpected expression instead of an int/float/bool literal: eid="

     

       
2043
       
2043
       
+
       
                                     << arg->eid() << " while E_INTLIT=" << Expression::E_INTLIT);

     

       
2042
       
2044
       
 
       


     

       
2043
       
2045
       
 
       
    return 0.0;

     

       
2044
       
2046
       
 
       
  }

     
···

       
2050
       
2052
       
 
       


     

       
2051
       
2053
       
 
       
  template <class Elem, size_t N>

     

       
2052
       
2054
       
 
       
  void checkOrResize(std::array<Elem, N>& cnt, size_t sz) {

     

       
2053
       
2053
       
-
       
    MZN_MIPD_assert_hard(cnt.size() == sz);

     

       
2055
       
2055
       
+
       
    MZN_MIPD__assert_hard(cnt.size() == sz);

     

       
2054
       
2056
       
 
       
  }

     

       
2055
       
2057
       
 
       


     

       
2056
       
2058
       
 
       
  template <class Array>

     
···

       
2058
       
2060
       
 
       
    ArrayLit* al = eval_array_lit(getEnv()->envi(), arg);

     

       
2059
       
2061
       
 
       
    //       if ( typeid(typename Array::pointer) == typeid(typename Array::iterator) )  // fixed

     

       
2060
       
2062
       
 
       
    //       array

     

       
2061
       
2061
       
-
       
    //         MZN_MIPD_assert_hard( vals.size() == al->v().size() );

     

       
2063
       
2063
       
+
       
    //         MZN_MIPD__assert_hard( vals.size() == al->v().size() );

     

       
2062
       
2064
       
 
       
    //       else

     

       
2063
       
2065
       
 
       
    //         vals.resize( al->v().size() );

     

       
2064
       
2066
       
 
       
    checkOrResize(vals, al->size());

     
···

       
2086
       
2088
       
 
       
    }

     

       
2087
       
2089
       
 
       
    //       os << "N cliques " << _aCliques.size() << "  total, "

     

       
2088
       
2090
       
 
       
    //          << nc << " final" << std::endl;

     

       
2089
       
2089
       
-
       
    MZN_MIPD_assert_hard(nc);

     

       
2090
       
2090
       
-
       
    MIPD_stats[N_POSTs_eqNmapsize] = static_cast<double>(_mNViews.size());

     

       
2091
       
2091
       
-
       
    double nSubintvAve = MIPD_stats[N_POSTs_NSubintvSum] / nc;

     

       
2092
       
2092
       
-
       
    MZN_MIPD_assert_hard(MIPD_stats[N_POSTs_NSubintvSum]);

     

       
2093
       
2093
       
-
       
    double dSubSizeAve = MIPD_stats[N_POSTs_SubSizeSum] / MIPD_stats[N_POSTs_NSubintvSum];

     

       
2094
       
2094
       
-
       
    os << MIPD_stats[N_POSTs_all]

     

       
2091
       
2091
       
+
       
    MZN_MIPD__assert_hard(nc);

     

       
2092
       
2092
       
+
       
    MIPD__stats[N_POSTs__eqNmapsize] = static_cast<double>(_mNViews.size());

     

       
2093
       
2093
       
+
       
    double nSubintvAve = MIPD__stats[N_POSTs__NSubintvSum] / nc;

     

       
2094
       
2094
       
+
       
    MZN_MIPD__assert_hard(MIPD__stats[N_POSTs__NSubintvSum]);

     

       
2095
       
2095
       
+
       
    double dSubSizeAve = MIPD__stats[N_POSTs__SubSizeSum] / MIPD__stats[N_POSTs__NSubintvSum];

     

       
2096
       
2096
       
+
       
    os << MIPD__stats[N_POSTs__all]

     

       
2095
       
2097
       
 
       
       << " POSTs"

     

       
2096
       
2096
       
-
       
#ifdef MZN_MIPDOMAINS_PRINTMORESTATS

     

       
2098
       
2098
       
+
       
#ifdef __MZN__MIPDOMAINS__PRINTMORESTATS

     

       
2097
       
2099
       
 
       
          " [ ";

     

       
2098
       
2098
       
-
       
    MZN_MIPDOMAINS_PRINTMORESTATS

     

       
2099
       
2099
       
-
       
    for (int i = N_POSTs_intCmpReif; i <= N_POSTs_floatAux; ++i) {

     

       
2100
       
2100
       
-
       
      os << MIPD_stats[i] << ',';

     

       
2100
       
2100
       
+
       
    for (int i = N_POSTs__intCmpReif; i <= N_POSTs__floatAux; ++i) {

     

       
2101
       
2101
       
+
       
      os << MIPD__stats[i] << ',';

     

       
2101
       
2102
       
 
       
    }

     

       
2102
       
2103
       
 
       
    os << " ], LINEQ [ ";

     

       
2103
       
2103
       
-
       
    for (int i = N_POSTs_eq2intlineq; i <= N_POSTs_eqNmapsize; ++i) {

     

       
2104
       
2104
       
-
       
      os << MIPD_stats[i] << ',';

     

       
2104
       
2104
       
+
       
    for (int i = N_POSTs__eq2intlineq; i <= N_POSTs__eqNmapsize; ++i) {

     

       
2105
       
2105
       
+
       
      os << MIPD__stats[i] << ',';

     

       
2105
       
2106
       
 
       
    }

     

       
2106
       
2107
       
 
       
    os << " ]"

     

       
2107
       
2108
       
 
       
#endif

     

       
2108
       
2109
       
 
       
          ", "

     

       
2109
       
2109
       
-
       
       << MIPD_stats[N_POSTs_varsDirect] << " / " << MIPD_stats[N_POSTs_varsInvolved] << " vars, "

     

       
2110
       
2110
       
-
       
       << nc << " cliques, " << MIPD_stats[N_POSTs_NSubintvMin] << " / " << nSubintvAve << " / "

     

       
2111
       
2111
       
-
       
       << MIPD_stats[N_POSTs_NSubintvMax] << " NSubIntv m/a/m, " << MIPD_stats[N_POSTs_SubSizeMin]

     

       
2112
       
2112
       
-
       
       << " / " << dSubSizeAve << " / " << MIPD_stats[N_POSTs_SubSizeMax] << " SubIntvSize m/a/m, "

     

       
2113
       
2113
       
-
       
       << MIPD_stats[N_POSTs_cliquesWithEqEncode] << "+" << MIPD_stats[N_POSTs_clEEEnforced] << "("

     

       
2114
       
2114
       
-
       
       << MIPD_stats[N_POSTs_clEEFound] << ")"

     

       
2110
       
2110
       
+
       
       << MIPD__stats[N_POSTs__varsDirect] << " / " << MIPD__stats[N_POSTs__varsInvolved]

     

       
2111
       
2111
       
+
       
       << " vars, " << nc << " cliques, " << MIPD__stats[N_POSTs__NSubintvMin] << " / "

     

       
2112
       
2112
       
+
       
       << nSubintvAve << " / " << MIPD__stats[N_POSTs__NSubintvMax] << " NSubIntv m/a/m, "

     

       
2113
       
2113
       
+
       
       << MIPD__stats[N_POSTs__SubSizeMin] << " / " << dSubSizeAve << " / "

     

       
2114
       
2114
       
+
       
       << MIPD__stats[N_POSTs__SubSizeMax] << " SubIntvSize m/a/m, "

     

       
2115
       
2115
       
+
       
       << MIPD__stats[N_POSTs__cliquesWithEqEncode] << "+" << MIPD__stats[N_POSTs__clEEEnforced]

     

       
2116
       
2116
       
+
       
       << "(" << MIPD__stats[N_POSTs__clEEFound] << ")"

     

       
2115
       
2117
       
 
       
       << " clq eq_encoded ";

     

       
2116
       
2118
       
 
       
    //       << std::flush

     

       
2117
       
2119
       
 
       
    if (TCliqueSorter::LinEqGraph::dCoefMax > 1.0) {

     
···

       
2156
       
2158
       
 
       
}

     

       
2157
       
2159
       
 
       
template <class N>

     

       
2158
       
2160
       
 
       
void SetOfIntervals<N>::cutOut(const Interval<N>& intv) {

     

       
2159
       
2159
       
-
       
  DBGOUT_MIPD_FLUSH("Cutting " << intv << " from " << (*this));

     

       
2161
       
2161
       
+
       
  DBGOUT_MIPD__("Cutting " << intv << " from " << (*this));

     

       
2160
       
2162
       
 
       
  if (this->empty()) {

     

       
2161
       
2163
       
 
       
    return;

     

       
2162
       
2164
       
 
       
  }

     
···

       
2167
       
2169
       
 
       
  if (this->begin() != it1) {

     

       
2168
       
2170
       
 
       
    --it1;

     

       
2169
       
2171
       
 
       
    const N it1l = it1->left;

     

       
2170
       
2170
       
-
       
    MZN_MIPD_assert_hard(it1l <= intv.left);

     

       
2172
       
2172
       
+
       
    MZN_MIPD__assert_hard(it1l <= intv.left);

     

       
2171
       
2173
       
 
       
    if (it1->right > intv.left) {  // split it

     

       
2172
       
2174
       
 
       
      it2Del1 = split(it1, intv.left).second;

     

       
2173
       
2175
       
 
       
      //         it1->right = intv.left;  READ-ONLY

     

       
2174
       
2176
       
 
       
      //         this->erase(it1);

     

       
2175
       
2177
       
 
       
      //         it1 = this->end();

     

       
2176
       
2178
       
 
       
      //         auto iR = this->insert( Interval<N>( it1l, intv.left ) );

     

       
2177
       
2177
       
-
       
      //         MZN_MIPD_assert_hard( iR.second );

     

       
2179
       
2179
       
+
       
      //         MZN_MIPD__assert_hard( iR.second );

     

       
2178
       
2180
       
 
       
    }

     

       
2179
       
2181
       
 
       
  }

     

       
2180
       
2180
       
-
       
  DBGOUT_MIPD_FLUSH("; after split 1: " << (*this));

     

       
2182
       
2182
       
+
       
  DBGOUT_MIPD__("; after split 1: " << (*this));

     

       
2181
       
2183
       
 
       
  // Processing the right end:

     

       
2182
       
2184
       
 
       
  auto it2 = this->lower_bound(Interval<N>(intv.right, intv.right + 1));

     

       
2183
       
2185
       
 
       
  auto it2Del2 = it2;

     

       
2184
       
2186
       
 
       
  if (this->begin() != it2) {

     

       
2185
       
2187
       
 
       
    --it2;

     

       
2186
       
2186
       
-
       
    MZN_MIPD_assert_hard(it2->left < intv.right);

     

       
2188
       
2188
       
+
       
    MZN_MIPD__assert_hard(it2->left < intv.right);

     

       
2187
       
2189
       
 
       
    const N it2r = it2->right;

     

       
2188
       
2190
       
 
       
    if ((Interval<N>::infPlus() == intv.right) ? (it2r > intv.right)

     

       
2189
       
2191
       
 
       
                                               : (it2r >= intv.right)) {  // >=: split it

     
···

       
2197
       
2199
       
 
       
      }

     

       
2198
       
2200
       
 
       
    }

     

       
2199
       
2201
       
 
       
  }

     

       
2200
       
2200
       
-
       
  DBGOUT_MIPD_FLUSH("; after split 2: " << (*this));

     

       
2201
       
2201
       
-
       
  DBGOUT_MIPD_FLUSH("; cutting out: " << SetOfIntervals(it2Del1, it2Del2));

     

       
2202
       
2202
       
+
       
  DBGOUT_MIPD__("; after split 2: " << (*this));

     

       
2203
       
2203
       
+
       
  DBGOUT_MIPD__("; cutting out: " << SetOfIntervals(it2Del1, it2Del2));

     

       
2202
       
2204
       
 
       
#ifdef MZN_DBG_CHECK_ITER_CUTOUT

     

       
2203
       
2205
       
 
       
  {

     

       
2204
       
2206
       
 
       
    auto it = this->begin();

     

       
2205
       
2207
       
 
       
    int nO = 0;

     

       
2206
       
2208
       
 
       
    do {

     

       
2207
       
2209
       
 
       
      if (it == it2Del1) {

     

       
2208
       
2208
       
-
       
        MZN_MIPD_assert_hard(!nO);

     

       
2210
       
2210
       
+
       
        MZN_MIPD__assert_hard(!nO);

     

       
2209
       
2211
       
 
       
        ++nO;

     

       
2210
       
2212
       
 
       
      }

     

       
2211
       
2213
       
 
       
      if (it == it2Del2) {

     

       
2212
       
2212
       
-
       
        MZN_MIPD_assert_hard(1 == nO);

     

       
2214
       
2214
       
+
       
        MZN_MIPD__assert_hard(1 == nO);

     

       
2213
       
2215
       
 
       
        ++nO;

     

       
2214
       
2216
       
 
       
      }

     

       
2215
       
2217
       
 
       
      if (this->end() == it) {

     
···

       
2217
       
2219
       
 
       
      }

     

       
2218
       
2220
       
 
       
      ++it;

     

       
2219
       
2221
       
 
       
    } while (true);

     

       
2220
       
2220
       
-
       
    MZN_MIPD_assert_hard(2 == nO);

     

       
2222
       
2222
       
+
       
    MZN_MIPD__assert_hard(2 == nO);

     

       
2221
       
2223
       
 
       
  }

     

       
2222
       
2224
       
 
       
#endif

     

       
2223
       
2225
       
 
       
  this->erase(it2Del1, it2Del2);

     
···

       
2225
       
2227
       
 
       
}

     

       
2226
       
2228
       
 
       
template <class N>

     

       
2227
       
2229
       
 
       
typename SetOfIntervals<N>::SplitResult SetOfIntervals<N>::split(iterator& it, N pos) {

     

       
2228
       
2228
       
-
       
  MZN_MIPD_assert_hard(pos >= it->left);

     

       
2229
       
2229
       
-
       
  MZN_MIPD_assert_hard(pos <= it->right);

     

       
2230
       
2230
       
+
       
  MZN_MIPD__assert_hard(pos >= it->left);

     

       
2231
       
2231
       
+
       
  MZN_MIPD__assert_hard(pos <= it->right);

     

       
2230
       
2232
       
 
       
  Interval<N> intvOld = *it;

     

       
2231
       
2233
       
 
       
  this->erase(it);

     

       
2232
       
2234
       
 
       
  auto it_01 = this->insert(Interval<N>(intvOld.left, pos));