or-tools-wasm 0.5.0 → 0.7.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +206 -54
- package/build/javascript/browser/cp_sat_module_loader.js +53 -0
- package/build/javascript/browser/cpsat_worker.js +135 -0
- package/build/javascript/browser/cpsat_worker_types.js +0 -0
- package/build/javascript/browser/index.js +5910 -0
- package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js +2568 -0
- package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js.map +1 -0
- package/build/javascript/lib/assets/{cp_sat_runtime-BUuF8d7w.wasm → cp_sat_runtime.wasm} +0 -0
- package/build/javascript/lib/assets/cp_sat_runtime.wasm.map +1 -0
- package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js +2642 -0
- package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js.map +1 -0
- package/build/javascript/lib/assets/{cp_sat_runtime_asyncify-CjMVqM1A.wasm → cp_sat_runtime_asyncify.wasm} +0 -0
- package/build/javascript/lib/assets/cp_sat_runtime_asyncify.wasm.map +1 -0
- package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js +145 -0
- package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js.map +1 -0
- package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js +2568 -0
- package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js.map +1 -0
- package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js +2642 -0
- package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js.map +1 -0
- package/build/javascript/lib/cp_sat_api.d.ts +277 -98
- package/build/javascript/lib/cp_sat_api.js +3364 -219
- package/build/javascript/lib/cp_sat_api.js.map +1 -1
- package/build/javascript/wasm/cp_sat_runtime.d.ts +51 -0
- package/build/javascript/wasm/cp_sat_runtime.js +10 -0
- package/build/javascript/wasm/cp_sat_runtime.wasm +0 -0
- package/build/javascript/wasm/cp_sat_runtime.wasm.map +1 -0
- package/build/javascript/wasm/cp_sat_runtime_asyncify.js +10 -0
- package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm +0 -0
- package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm.map +1 -0
- package/javascript/lib/cp_sat_api.ts +475 -0
- package/javascript/lib/cp_sat_module_loader.bundled.ts +58 -0
- package/javascript/lib/cp_sat_module_loader.ts +57 -0
- package/javascript/lib/cpsat_worker.ts +160 -0
- package/javascript/lib/cpsat_worker_types.ts +32 -0
- package/javascript/lib/generated/sat_parameters.ts +2760 -0
- package/javascript/lib/index.ts +8 -0
- package/javascript/lib/internal_wasm_asyncify.d.ts +15 -0
- package/javascript/lib/vite-shims.d.ts +25 -0
- package/javascript/lib/webassembly_promising.d.ts +7 -0
- package/package.json +46 -7
- package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js +0 -2565
- package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js.map +0 -1
- package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js +0 -2639
- package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js.map +0 -1
- package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js +0 -139
- package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js.map +0 -1
- package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js +0 -2565
- package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js.map +0 -1
- package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js +0 -2639
- package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js.map +0 -1
- package/build/javascript/lib/chunks/index-Cq3lJx2c.js +0 -3815
- package/build/javascript/lib/chunks/index-Cq3lJx2c.js.map +0 -1
|
@@ -1,10 +1,3 @@
|
|
|
1
|
-
import { MainModule } from '../../build/javascript/wasm/cp_sat_runtime.js';
|
|
2
|
-
|
|
3
|
-
declare type CancelSolve = {
|
|
4
|
-
type: 'cancel_solve';
|
|
5
|
-
id: number;
|
|
6
|
-
};
|
|
7
|
-
|
|
8
1
|
declare const CpSat: CpSatApi;
|
|
9
2
|
export { CpSat }
|
|
10
3
|
export default CpSat;
|
|
@@ -18,7 +11,7 @@ export declare type CpSatApi = {
|
|
|
18
11
|
}>;
|
|
19
12
|
getSchemas(): Promise<SchemaPair>;
|
|
20
13
|
createModel(model: Record<string, unknown>): Promise<Uint8Array>;
|
|
21
|
-
loadModule(): Promise<
|
|
14
|
+
loadModule(): Promise<unknown>;
|
|
22
15
|
setWorkerBridgeEnabled(enabled: boolean): void;
|
|
23
16
|
isWorkerBridgeEnabled(): boolean;
|
|
24
17
|
cancelSolve(): Promise<void>;
|
|
@@ -34,7 +27,7 @@ export declare type CpSatSolveResult = {
|
|
|
34
27
|
/**
|
|
35
28
|
* Contains the definitions for all the sat algorithm parameters and their
|
|
36
29
|
* default values.
|
|
37
|
-
* NEXT TAG:
|
|
30
|
+
* NEXT TAG: 356
|
|
38
31
|
*/
|
|
39
32
|
declare type SatParameters = {
|
|
40
33
|
/**
|
|
@@ -132,7 +125,7 @@ declare type SatParameters = {
|
|
|
132
125
|
*/
|
|
133
126
|
minimizationAlgorithm?: SatParameters_ConflictMinimizationAlgorithm | SatParameters_ConflictMinimizationAlgorithm_Name;
|
|
134
127
|
/**
|
|
135
|
-
* @default
|
|
128
|
+
* @default BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS
|
|
136
129
|
*/
|
|
137
130
|
binaryMinimizationAlgorithm?: SatParameters_BinaryMinizationAlgorithm | SatParameters_BinaryMinizationAlgorithm_Name;
|
|
138
131
|
/**
|
|
@@ -144,6 +137,58 @@ declare type SatParameters = {
|
|
|
144
137
|
* @default true
|
|
145
138
|
*/
|
|
146
139
|
subsumptionDuringConflictAnalysis?: boolean;
|
|
140
|
+
/**
|
|
141
|
+
* It is possible that "intermediate" clauses during conflict resolution
|
|
142
|
+
* subsumes some of the clauses that propagated. This is quite cheap to detect
|
|
143
|
+
* and result in more subsumption/strengthening of clauses.
|
|
144
|
+
*
|
|
145
|
+
* @default true
|
|
146
|
+
*/
|
|
147
|
+
extraSubsumptionDuringConflictAnalysis?: boolean;
|
|
148
|
+
/**
|
|
149
|
+
* Try even more subsumption options during conflict analysis.
|
|
150
|
+
*
|
|
151
|
+
* @default true
|
|
152
|
+
*/
|
|
153
|
+
decisionSubsumptionDuringConflictAnalysis?: boolean;
|
|
154
|
+
/**
|
|
155
|
+
* If >=0, each time we have a conflict, we try to subsume the last n learned
|
|
156
|
+
* clause with it.
|
|
157
|
+
*
|
|
158
|
+
* @default 4
|
|
159
|
+
*/
|
|
160
|
+
eagerlySubsumeLastNConflicts?: number;
|
|
161
|
+
/**
|
|
162
|
+
* If we remove clause that we now are "implied" by others. Note that this
|
|
163
|
+
* might not always be good as we might loose some propagation power.
|
|
164
|
+
*
|
|
165
|
+
* @default true
|
|
166
|
+
*/
|
|
167
|
+
subsumeDuringVivification?: boolean;
|
|
168
|
+
/**
|
|
169
|
+
* If true, try to backtrack as little as possible on conflict and re-imply
|
|
170
|
+
* the clauses later.
|
|
171
|
+
* This means we discard less propagation than traditional backjumping, but
|
|
172
|
+
* requites additional bookkeeping to handle reimplication.
|
|
173
|
+
* See: https://doi.org/10.1007/978-3-319-94144-8_7
|
|
174
|
+
*
|
|
175
|
+
* @default false
|
|
176
|
+
*/
|
|
177
|
+
useChronologicalBacktracking?: boolean;
|
|
178
|
+
/**
|
|
179
|
+
* If chronological backtracking is enabled, this is the maximum number of
|
|
180
|
+
* levels we will backjump over, otherwise we will backtrack.
|
|
181
|
+
*
|
|
182
|
+
* @default 50
|
|
183
|
+
*/
|
|
184
|
+
maxBackjumpLevels?: number;
|
|
185
|
+
/**
|
|
186
|
+
* If chronological backtracking is enabled, this is the minimum number of
|
|
187
|
+
* conflicts before we will consider backjumping.
|
|
188
|
+
*
|
|
189
|
+
* @default 1000
|
|
190
|
+
*/
|
|
191
|
+
chronologicalBacktrackMinConflicts?: number;
|
|
147
192
|
/**
|
|
148
193
|
* ==========================================================================
|
|
149
194
|
* Clause database management
|
|
@@ -153,6 +198,12 @@ declare type SatParameters = {
|
|
|
153
198
|
* @default 10000
|
|
154
199
|
*/
|
|
155
200
|
clauseCleanupPeriod?: number;
|
|
201
|
+
/**
|
|
202
|
+
* Increase clause_cleanup_period by this amount after each cleanup.
|
|
203
|
+
*
|
|
204
|
+
* @default 0
|
|
205
|
+
*/
|
|
206
|
+
clauseCleanupPeriodIncrement?: number;
|
|
156
207
|
/**
|
|
157
208
|
* During a cleanup, we will always keep that number of "deletable" clauses.
|
|
158
209
|
* Note that this doesn't include the "protected" clauses.
|
|
@@ -168,17 +219,34 @@ declare type SatParameters = {
|
|
|
168
219
|
* @default 0
|
|
169
220
|
*/
|
|
170
221
|
clauseCleanupRatio?: number;
|
|
171
|
-
/**
|
|
172
|
-
* @default PROTECTION_NONE
|
|
173
|
-
*/
|
|
174
|
-
clauseCleanupProtection?: SatParameters_ClauseProtection | SatParameters_ClauseProtection_Name;
|
|
175
222
|
/**
|
|
176
223
|
* All the clauses with a LBD (literal blocks distance) lower or equal to this
|
|
177
224
|
* parameters will always be kept.
|
|
225
|
+
* Note that the LBD of a clause that just propagated is 1 + number of
|
|
226
|
+
* different decision levels of its literals. So that the "classic" LBD of a
|
|
227
|
+
* learned conflict is the same as its LBD when we backjump and then propagate
|
|
228
|
+
* it.
|
|
178
229
|
*
|
|
179
230
|
* @default 5
|
|
180
231
|
*/
|
|
181
232
|
clauseCleanupLbdBound?: number;
|
|
233
|
+
/**
|
|
234
|
+
* All the clause with a LBD lower or equal to this will be kept except if
|
|
235
|
+
* its activity hasn't been bumped in the last 32 cleanup phase. Note that
|
|
236
|
+
* this has no effect if it is <= clause_cleanup_lbd_bound.
|
|
237
|
+
*
|
|
238
|
+
* @default 0
|
|
239
|
+
*/
|
|
240
|
+
clauseCleanupLbdTier1?: number;
|
|
241
|
+
/**
|
|
242
|
+
* All the clause with a LBD lower or equal to this will be kept except if its
|
|
243
|
+
* activity hasn't been bumped since the previous cleanup phase. Note that
|
|
244
|
+
* this has no effect if it is <= clause_cleanup_lbd_bound or <=
|
|
245
|
+
* clause_cleanup_lbd_tier1.
|
|
246
|
+
*
|
|
247
|
+
* @default 0
|
|
248
|
+
*/
|
|
249
|
+
clauseCleanupLbdTier2?: number;
|
|
182
250
|
/**
|
|
183
251
|
* @default CLAUSE_ACTIVITY
|
|
184
252
|
*/
|
|
@@ -447,6 +515,11 @@ declare type SatParameters = {
|
|
|
447
515
|
*/
|
|
448
516
|
logToResponse?: boolean;
|
|
449
517
|
/**
|
|
518
|
+
* Experimental.
|
|
519
|
+
* This is an old experiment, it might cause crashes in multi-thread and you
|
|
520
|
+
* should double check the solver result. It can still be used if you only
|
|
521
|
+
* care about feasible solutions (these are checked) and it gives good result
|
|
522
|
+
* on your problem. We might revive it at some point.
|
|
450
523
|
* Whether to use pseudo-Boolean resolution to analyze a conflict. Note that
|
|
451
524
|
* this option only make sense if your problem is modelized using
|
|
452
525
|
* pseudo-Boolean constraints. If you only have clauses, this shouldn't change
|
|
@@ -568,6 +641,16 @@ declare type SatParameters = {
|
|
|
568
641
|
* @default true
|
|
569
642
|
*/
|
|
570
643
|
cpModelUseSatPresolve?: boolean;
|
|
644
|
+
/**
|
|
645
|
+
* If we try to load at most ones and exactly ones constraints when running
|
|
646
|
+
* the pure SAT presolve. Or if we just ignore them.
|
|
647
|
+
* If one detects at_most_one via merge_at_most_one_work_limit or exactly one
|
|
648
|
+
* with find_clauses_that_are_exactly_one, it might be good to also set this
|
|
649
|
+
* to true.
|
|
650
|
+
*
|
|
651
|
+
* @default false
|
|
652
|
+
*/
|
|
653
|
+
loadAtMostOnesInSatPresolve?: boolean;
|
|
571
654
|
/**
|
|
572
655
|
* If cp_model_presolve is true and there is a large proportion of fixed
|
|
573
656
|
* variable after the first model copy, remap all the model to a dense set of
|
|
@@ -616,6 +699,12 @@ declare type SatParameters = {
|
|
|
616
699
|
* @default true
|
|
617
700
|
*/
|
|
618
701
|
expandReservoirConstraints?: boolean;
|
|
702
|
+
/**
|
|
703
|
+
* Max domain size for expanding linear2 constraints (ax + by ==/!= c).
|
|
704
|
+
*
|
|
705
|
+
* @default 8
|
|
706
|
+
*/
|
|
707
|
+
maxDomainSizeForLinear2Expansion?: number;
|
|
619
708
|
/**
|
|
620
709
|
* Mainly useful for testing.
|
|
621
710
|
* If this and expand_reservoir_constraints is true, we use a different
|
|
@@ -736,6 +825,16 @@ declare type SatParameters = {
|
|
|
736
825
|
* @default true
|
|
737
826
|
*/
|
|
738
827
|
findBigLinearOverlap?: boolean;
|
|
828
|
+
/**
|
|
829
|
+
* By propagating (or just using binary clauses), one can detect that all
|
|
830
|
+
* literal of a clause are actually in at most one relationship. Thus this
|
|
831
|
+
* constraint can be promoted to an exactly one constraints. This should help
|
|
832
|
+
* as it convey more structure. Note that this is expensive, so we have a
|
|
833
|
+
* deterministic limit in place.
|
|
834
|
+
*
|
|
835
|
+
* @default true
|
|
836
|
+
*/
|
|
837
|
+
findClausesThatAreExactlyOne?: boolean;
|
|
739
838
|
/**
|
|
740
839
|
* ==========================================================================
|
|
741
840
|
* Inprocessing
|
|
@@ -781,6 +880,22 @@ declare type SatParameters = {
|
|
|
781
880
|
* @default false
|
|
782
881
|
*/
|
|
783
882
|
inprocessingMinimizationUseAllOrderings?: boolean;
|
|
883
|
+
/**
|
|
884
|
+
* Whether we use the algorithm described in "Clausal Congruence closure",
|
|
885
|
+
* Armin Biere, Katalin Fazekas, Mathias Fleury, Nils Froleyks, 2024.
|
|
886
|
+
* Note that we only have a basic version currently.
|
|
887
|
+
*
|
|
888
|
+
* @default true
|
|
889
|
+
*/
|
|
890
|
+
inprocessingUseCongruenceClosure?: boolean;
|
|
891
|
+
/**
|
|
892
|
+
* Whether we use the SAT sweeping algorithm described in "Clausal Equivalence
|
|
893
|
+
* Sweeping", Armin Biere, Katalin Fazekas, Mathias Fleury, Nils Froleyks,
|
|
894
|
+
* 2025.
|
|
895
|
+
*
|
|
896
|
+
* @default false
|
|
897
|
+
*/
|
|
898
|
+
inprocessingUseSatSweeping?: boolean;
|
|
784
899
|
/**
|
|
785
900
|
* ==========================================================================
|
|
786
901
|
* Multithread
|
|
@@ -890,6 +1005,15 @@ declare type SatParameters = {
|
|
|
890
1005
|
* @default true
|
|
891
1006
|
*/
|
|
892
1007
|
shareLevelZeroBounds?: boolean;
|
|
1008
|
+
/**
|
|
1009
|
+
* Allows sharing of the bounds on linear2 discovered at level 0. This is
|
|
1010
|
+
* mainly interesting on scheduling type of problems when we branch on
|
|
1011
|
+
* precedences.
|
|
1012
|
+
* Warning: This currently non-deterministic.
|
|
1013
|
+
*
|
|
1014
|
+
* @default false
|
|
1015
|
+
*/
|
|
1016
|
+
shareLinear2Bounds?: boolean;
|
|
893
1017
|
/**
|
|
894
1018
|
* Allows sharing of new learned binary clause between workers.
|
|
895
1019
|
*
|
|
@@ -900,7 +1024,7 @@ declare type SatParameters = {
|
|
|
900
1024
|
* Allows sharing of short glue clauses between workers.
|
|
901
1025
|
* Implicitly disabled if share_binary_clauses is false.
|
|
902
1026
|
*
|
|
903
|
-
* @default
|
|
1027
|
+
* @default true
|
|
904
1028
|
*/
|
|
905
1029
|
shareGlueClauses?: boolean;
|
|
906
1030
|
/**
|
|
@@ -916,6 +1040,75 @@ declare type SatParameters = {
|
|
|
916
1040
|
* @default 1
|
|
917
1041
|
*/
|
|
918
1042
|
shareGlueClausesDtime?: number;
|
|
1043
|
+
/**
|
|
1044
|
+
* ==========================================================================
|
|
1045
|
+
* Proofs
|
|
1046
|
+
* ==========================================================================
|
|
1047
|
+
* If true, inferred clauses are checked with an LRAT checker as they are
|
|
1048
|
+
* learned, in presolve (reduced to trivial simplifications if
|
|
1049
|
+
* cp_model_presolve is false), and in each worker. As of December 2025, this
|
|
1050
|
+
* only works with pure SAT problems, with
|
|
1051
|
+
* - cp_model_presolve = false,
|
|
1052
|
+
* - linearization_level <= 1,
|
|
1053
|
+
* - symmetry_level <= 1.
|
|
1054
|
+
*
|
|
1055
|
+
* @default false
|
|
1056
|
+
*/
|
|
1057
|
+
checkLratProof?: boolean;
|
|
1058
|
+
/**
|
|
1059
|
+
* If true, and if output_lrat_proof is true and the problem is UNSAT, check
|
|
1060
|
+
* that the merged proof file is valid, i.e., that clause sharing between
|
|
1061
|
+
* workers is correct. This checks each inferred clause, so you might want to
|
|
1062
|
+
* disable check_lrat_proof to avoid redundant work. As of November 2025, this
|
|
1063
|
+
* only works for pure SAT problems, with num_workers = 1.
|
|
1064
|
+
*
|
|
1065
|
+
* @default false
|
|
1066
|
+
*/
|
|
1067
|
+
checkMergedLratProof?: boolean;
|
|
1068
|
+
/**
|
|
1069
|
+
* If true, an LRAT proof that all the clauses inferred by the solver are
|
|
1070
|
+
* valid is output to several files (one for presolve -- reduced to trivial
|
|
1071
|
+
* simplifications if cp_model_presolve is false, one per worker, and one for
|
|
1072
|
+
* the merged proof). As of December 2025, this only works for pure SAT
|
|
1073
|
+
* problems, with
|
|
1074
|
+
* - cp_model_presolve = false,
|
|
1075
|
+
* - linearization_level <= 1,
|
|
1076
|
+
* - symmetry_level <= 1.
|
|
1077
|
+
*
|
|
1078
|
+
* @default false
|
|
1079
|
+
*/
|
|
1080
|
+
outputLratProof?: boolean;
|
|
1081
|
+
/**
|
|
1082
|
+
* If true, and if the problem is UNSAT, a DRAT proof of this UNSAT property
|
|
1083
|
+
* is checked after the solver has finished. As of November 2025, this only
|
|
1084
|
+
* works for pure SAT problems, with
|
|
1085
|
+
* - num_workers = 1,
|
|
1086
|
+
* - cp_model_presolve = false,
|
|
1087
|
+
* - linearization_level <= 1,
|
|
1088
|
+
* - symmetry_level <= 1.
|
|
1089
|
+
*
|
|
1090
|
+
* @default false
|
|
1091
|
+
*/
|
|
1092
|
+
checkDratProof?: boolean;
|
|
1093
|
+
/**
|
|
1094
|
+
* If true, a DRAT proof that all the clauses inferred by the solver are valid
|
|
1095
|
+
* is output to a file. As of December 2025, this only works for pure SAT
|
|
1096
|
+
* problems, with
|
|
1097
|
+
* - num_workers = 1,
|
|
1098
|
+
* - cp_model_presolve = false,
|
|
1099
|
+
* - linearization_level <= 1,
|
|
1100
|
+
* - symmetry_level <= 1.
|
|
1101
|
+
*
|
|
1102
|
+
* @default false
|
|
1103
|
+
*/
|
|
1104
|
+
outputDratProof?: boolean;
|
|
1105
|
+
/**
|
|
1106
|
+
* The maximum time allowed to check the DRAT proof (this can take more time
|
|
1107
|
+
* than the solve itself). Only used if check_drat_proof is true.
|
|
1108
|
+
*
|
|
1109
|
+
* @default inf
|
|
1110
|
+
*/
|
|
1111
|
+
maxDratTimeInSeconds?: number;
|
|
919
1112
|
/**
|
|
920
1113
|
* ==========================================================================
|
|
921
1114
|
* Debugging parameters
|
|
@@ -946,6 +1139,12 @@ declare type SatParameters = {
|
|
|
946
1139
|
* @default false
|
|
947
1140
|
*/
|
|
948
1141
|
debugCrashIfPresolveBreaksHint?: boolean;
|
|
1142
|
+
/**
|
|
1143
|
+
* Crash if the LRAT UNSAT proof is invalid.
|
|
1144
|
+
*
|
|
1145
|
+
* @default false
|
|
1146
|
+
*/
|
|
1147
|
+
debugCrashIfLratCheckFails?: boolean;
|
|
949
1148
|
/**
|
|
950
1149
|
* ==========================================================================
|
|
951
1150
|
* Max-sat parameters
|
|
@@ -1026,6 +1225,14 @@ declare type SatParameters = {
|
|
|
1026
1225
|
* @default true
|
|
1027
1226
|
*/
|
|
1028
1227
|
usePrecedencesInDisjunctiveConstraint?: boolean;
|
|
1228
|
+
/**
|
|
1229
|
+
* At root level, we might compute the transitive closure of "precedences"
|
|
1230
|
+
* relations so that we can exploit that in scheduling problems. Setting this
|
|
1231
|
+
* to zero disable the feature.
|
|
1232
|
+
*
|
|
1233
|
+
* @default 1000000
|
|
1234
|
+
*/
|
|
1235
|
+
transitivePrecedencesWorkLimit?: number;
|
|
1029
1236
|
/**
|
|
1030
1237
|
* Create one literal for each disjunction of two pairs of tasks. This slows
|
|
1031
1238
|
* down the solve time, but improves the lower bound of the objective in the
|
|
@@ -1523,7 +1730,7 @@ declare type SatParameters = {
|
|
|
1523
1730
|
* Specifying a negative number uses a heuristic to select an appropriate
|
|
1524
1731
|
* number of shared tree workeres based on the total number of workers.
|
|
1525
1732
|
*
|
|
1526
|
-
* @default
|
|
1733
|
+
* @default -1
|
|
1527
1734
|
*/
|
|
1528
1735
|
sharedTreeNumWorkers?: number;
|
|
1529
1736
|
/**
|
|
@@ -1585,12 +1792,22 @@ declare type SatParameters = {
|
|
|
1585
1792
|
*/
|
|
1586
1793
|
sharedTreeBalanceTolerance?: number;
|
|
1587
1794
|
/**
|
|
1588
|
-
*
|
|
1589
|
-
*
|
|
1590
|
-
*
|
|
1591
|
-
*
|
|
1592
|
-
*
|
|
1593
|
-
|
|
1795
|
+
* How much dtime a worker will wait between proposing splits.
|
|
1796
|
+
* This limits the contention in splitting the shared tree, and also reduces
|
|
1797
|
+
* the number of too-easy subtrees that are generates.
|
|
1798
|
+
*
|
|
1799
|
+
* @default 0
|
|
1800
|
+
*/
|
|
1801
|
+
sharedTreeSplitMinDtime?: number;
|
|
1802
|
+
/**
|
|
1803
|
+
* Whether we enumerate all solutions of a problem without objective.
|
|
1804
|
+
* WARNING:
|
|
1805
|
+
* - This can be used with num_workers > 1 but then each solutions can be
|
|
1806
|
+
* found more than once, so it is up to the client to deduplicate them.
|
|
1807
|
+
* - If keep_all_feasible_solutions_in_presolve is unset, we will set it to
|
|
1808
|
+
* true as otherwise, many feasible solution can just be removed by the
|
|
1809
|
+
* presolve. It is still possible to manually set this to false if one only
|
|
1810
|
+
* wants to enumerate all solutions of the presolved model.
|
|
1594
1811
|
*
|
|
1595
1812
|
* @default false
|
|
1596
1813
|
*/
|
|
@@ -1690,12 +1907,29 @@ declare type SatParameters = {
|
|
|
1690
1907
|
useLnsOnly?: boolean;
|
|
1691
1908
|
/**
|
|
1692
1909
|
* Size of the top-n different solutions kept by the solver.
|
|
1693
|
-
* This parameter must be > 0.
|
|
1694
|
-
*
|
|
1910
|
+
* This parameter must be > 0. Currently, having this larger than one mainly
|
|
1911
|
+
* impact the "base" solution chosen for a LNS/LS fragment.
|
|
1695
1912
|
*
|
|
1696
1913
|
* @default 3
|
|
1697
1914
|
*/
|
|
1698
1915
|
solutionPoolSize?: number;
|
|
1916
|
+
/**
|
|
1917
|
+
* If solution_pool_size is <= this, we will use DP to keep a "diverse" set
|
|
1918
|
+
* of solutions (the one further apart via hamming distance) in the pool.
|
|
1919
|
+
* Setting this to large value might be slow, especially if your solution are
|
|
1920
|
+
* large.
|
|
1921
|
+
*
|
|
1922
|
+
* @default 10
|
|
1923
|
+
*/
|
|
1924
|
+
solutionPoolDiversityLimit?: number;
|
|
1925
|
+
/**
|
|
1926
|
+
* In order to not get stuck in local optima, when this is non-zero, we try to
|
|
1927
|
+
* also work on "older" solutions with a worse objective value so we get a
|
|
1928
|
+
* chance to follow a different LS/LNS trajectory.
|
|
1929
|
+
*
|
|
1930
|
+
* @default 1
|
|
1931
|
+
*/
|
|
1932
|
+
alternativePoolSize?: number;
|
|
1699
1933
|
/**
|
|
1700
1934
|
* Turns on relaxation induced neighborhood generator.
|
|
1701
1935
|
*
|
|
@@ -2131,6 +2365,20 @@ declare type SatParameters = {
|
|
|
2131
2365
|
* @default false
|
|
2132
2366
|
*/
|
|
2133
2367
|
detectLinearizedProduct?: boolean;
|
|
2368
|
+
/**
|
|
2369
|
+
* This should be better on integer problems.
|
|
2370
|
+
* But it is still work in progress.
|
|
2371
|
+
*
|
|
2372
|
+
* @default false
|
|
2373
|
+
*/
|
|
2374
|
+
useNewIntegerConflictResolution?: boolean;
|
|
2375
|
+
/**
|
|
2376
|
+
* If true, and during integer conflict resolution (icr) the 1-UIP is an
|
|
2377
|
+
* integer literal for which we do not have an associated Boolean. Create one.
|
|
2378
|
+
*
|
|
2379
|
+
* @default true
|
|
2380
|
+
*/
|
|
2381
|
+
create1uipBooleanDuringIcr?: boolean;
|
|
2134
2382
|
/**
|
|
2135
2383
|
* ==========================================================================
|
|
2136
2384
|
* MIP -> CP-SAT (i.e. IP with integer coeff) conversion parameters that are
|
|
@@ -2280,13 +2528,11 @@ declare type SatParameters = {
|
|
|
2280
2528
|
*/
|
|
2281
2529
|
declare enum SatParameters_BinaryMinizationAlgorithm {
|
|
2282
2530
|
NO_BINARY_MINIMIZATION = 0,
|
|
2283
|
-
|
|
2284
|
-
|
|
2285
|
-
BINARY_MINIMIZATION_WITH_REACHABILITY = 2,
|
|
2286
|
-
EXPERIMENTAL_BINARY_MINIMIZATION = 3
|
|
2531
|
+
BINARY_MINIMIZATION_FROM_UIP = 1,
|
|
2532
|
+
BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = 5
|
|
2287
2533
|
}
|
|
2288
2534
|
|
|
2289
|
-
declare type SatParameters_BinaryMinizationAlgorithm_Name = 'NO_BINARY_MINIMIZATION' | '
|
|
2535
|
+
declare type SatParameters_BinaryMinizationAlgorithm_Name = 'NO_BINARY_MINIMIZATION' | 'BINARY_MINIMIZATION_FROM_UIP' | 'BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS';
|
|
2290
2536
|
|
|
2291
2537
|
/**
|
|
2292
2538
|
* The clauses that will be kept during a cleanup are the ones that come
|
|
@@ -2305,25 +2551,6 @@ declare enum SatParameters_ClauseOrdering {
|
|
|
2305
2551
|
|
|
2306
2552
|
declare type SatParameters_ClauseOrdering_Name = 'CLAUSE_ACTIVITY' | 'CLAUSE_LBD';
|
|
2307
2553
|
|
|
2308
|
-
/**
|
|
2309
|
-
* Each time a clause activity is bumped, the clause has a chance to be
|
|
2310
|
-
* protected during the next cleanup phase. Note that clauses used as a reason
|
|
2311
|
-
* are always protected.
|
|
2312
|
-
*/
|
|
2313
|
-
declare enum SatParameters_ClauseProtection {
|
|
2314
|
-
PROTECTION_NONE = 0,
|
|
2315
|
-
/**
|
|
2316
|
-
* No protection.
|
|
2317
|
-
*/
|
|
2318
|
-
PROTECTION_ALWAYS = 1,
|
|
2319
|
-
/**
|
|
2320
|
-
* Protect all clauses whose activity is bumped.
|
|
2321
|
-
*/
|
|
2322
|
-
PROTECTION_LBD = 2
|
|
2323
|
-
}
|
|
2324
|
-
|
|
2325
|
-
declare type SatParameters_ClauseProtection_Name = 'PROTECTION_NONE' | 'PROTECTION_ALWAYS' | 'PROTECTION_LBD';
|
|
2326
|
-
|
|
2327
2554
|
/**
|
|
2328
2555
|
* ==========================================================================
|
|
2329
2556
|
* Conflict analysis
|
|
@@ -2333,11 +2560,10 @@ declare type SatParameters_ClauseProtection_Name = 'PROTECTION_NONE' | 'PROTECTI
|
|
|
2333
2560
|
declare enum SatParameters_ConflictMinimizationAlgorithm {
|
|
2334
2561
|
NONE = 0,
|
|
2335
2562
|
SIMPLE = 1,
|
|
2336
|
-
RECURSIVE = 2
|
|
2337
|
-
EXPERIMENTAL = 3
|
|
2563
|
+
RECURSIVE = 2
|
|
2338
2564
|
}
|
|
2339
2565
|
|
|
2340
|
-
declare type SatParameters_ConflictMinimizationAlgorithm_Name = 'NONE' | 'SIMPLE' | 'RECURSIVE'
|
|
2566
|
+
declare type SatParameters_ConflictMinimizationAlgorithm_Name = 'NONE' | 'SIMPLE' | 'RECURSIVE';
|
|
2341
2567
|
|
|
2342
2568
|
/**
|
|
2343
2569
|
* Rounding method to use for feasibility pump.
|
|
@@ -2567,53 +2793,6 @@ declare type SchemaPair = {
|
|
|
2567
2793
|
sat_parameters: string;
|
|
2568
2794
|
};
|
|
2569
2795
|
|
|
2570
|
-
declare type SchemaRequest = {
|
|
2571
|
-
type: 'getSchemas';
|
|
2572
|
-
id: number;
|
|
2573
|
-
};
|
|
2574
|
-
|
|
2575
|
-
declare type SolveRequest = {
|
|
2576
|
-
type: 'solve';
|
|
2577
|
-
id: number;
|
|
2578
|
-
modelBytes: Uint8Array;
|
|
2579
|
-
paramsBytes?: Uint8Array;
|
|
2580
|
-
};
|
|
2581
|
-
|
|
2582
2796
|
declare type SolverParams = Uint8Array | SatParameters | null;
|
|
2583
2797
|
|
|
2584
|
-
declare type ValidateRequest = {
|
|
2585
|
-
type: 'validate';
|
|
2586
|
-
id: number;
|
|
2587
|
-
modelBytes: Uint8Array;
|
|
2588
|
-
};
|
|
2589
|
-
|
|
2590
|
-
export declare type WorkerRequest = SolveRequest | ValidateRequest | SchemaRequest | CancelSolve;
|
|
2591
|
-
|
|
2592
|
-
export declare type WorkerResponse = {
|
|
2593
|
-
type: 'ready';
|
|
2594
|
-
} | {
|
|
2595
|
-
type: 'solveResult';
|
|
2596
|
-
id: number;
|
|
2597
|
-
bytes: Uint8Array;
|
|
2598
|
-
} | {
|
|
2599
|
-
type: 'validateResult';
|
|
2600
|
-
id: number;
|
|
2601
|
-
ok: boolean;
|
|
2602
|
-
message: string;
|
|
2603
|
-
} | {
|
|
2604
|
-
type: 'schemaResult';
|
|
2605
|
-
id: number;
|
|
2606
|
-
schemas: {
|
|
2607
|
-
cp_model: string;
|
|
2608
|
-
sat_parameters: string;
|
|
2609
|
-
};
|
|
2610
|
-
} | {
|
|
2611
|
-
type: 'solved_cancelled';
|
|
2612
|
-
id: number;
|
|
2613
|
-
} | {
|
|
2614
|
-
type: 'error';
|
|
2615
|
-
id: number;
|
|
2616
|
-
error: string;
|
|
2617
|
-
};
|
|
2618
|
-
|
|
2619
2798
|
export { }
|