tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7714e32
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 +37 -126
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +44 -12
- package/dist/index.d.ts +44 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1154
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +112 -718
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +17 -15
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +109 -108
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +169 -142
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +16 -20
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +16 -19
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -213
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/transfer.ts +32 -32
- package/src/values.ts +80 -70
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
- /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/lar_term.h), MIT license, see z3-license.txt. A linear combination of
|
|
2
|
+
// columns, kept in a u_map so that its iteration order is Z3's.
|
|
3
|
+
import { getIdentityHash, ObjMap } from "../hashtable";
|
|
4
|
+
import { Rational } from "../rational";
|
|
5
|
+
import { Impq } from "./numeric-pair";
|
|
6
|
+
|
|
7
|
+
export class LarTerm {
|
|
8
|
+
readonly coeffs = new ObjMap<Rational>(getIdentityHash);
|
|
9
|
+
column = -1;
|
|
10
|
+
|
|
11
|
+
constructor(entries: Iterable<[number, Rational]> = []) {
|
|
12
|
+
for (const entry of entries) this.addMonomial(entry[1], entry[0]);
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
get size() {
|
|
16
|
+
return this.coeffs.size;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
clear() {
|
|
20
|
+
this.coeffs.clear();
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
addMonomial(coeff: Rational, column: number) {
|
|
24
|
+
if (coeff.isZero()) return;
|
|
25
|
+
const existing = this.coeffs.get(column);
|
|
26
|
+
if (existing === undefined) {
|
|
27
|
+
this.coeffs.set(column, coeff);
|
|
28
|
+
return;
|
|
29
|
+
}
|
|
30
|
+
const sum = existing.add(coeff);
|
|
31
|
+
if (sum.isZero()) this.coeffs.delete(column);
|
|
32
|
+
else this.coeffs.replace(column, sum);
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
// apply: the value of the term at the column values.
|
|
36
|
+
apply(values: Impq[]) {
|
|
37
|
+
let value = Impq.zero;
|
|
38
|
+
for (const entry of this.coeffs) value = value.add(values[entry[0]].mul(entry[1]));
|
|
39
|
+
return value;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
// subst_by_term: replaces the term column by its definition.
|
|
43
|
+
substByTerm(term: LarTerm, termColumn: number) {
|
|
44
|
+
const coeff = this.coeffs.get(termColumn);
|
|
45
|
+
if (coeff === undefined) return;
|
|
46
|
+
this.coeffs.delete(termColumn);
|
|
47
|
+
for (const entry of term.coeffs) this.addMonomial(coeff.mul(entry[1]), entry[0]);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
// get_normalized_by_min_var: the term divided by its first coefficient, and that coefficient.
|
|
51
|
+
getNormalized() {
|
|
52
|
+
const entries = [...this.coeffs];
|
|
53
|
+
if (entries.length === 0) return { term: this, coeff: Rational.one };
|
|
54
|
+
const coeff = entries[0][1];
|
|
55
|
+
if (coeff.equals(Rational.one)) return { term: this, coeff };
|
|
56
|
+
const term = new LarTerm();
|
|
57
|
+
term.addMonomial(Rational.one, entries[0][0]);
|
|
58
|
+
for (let index = 1; index < entries.length; index++)
|
|
59
|
+
term.addMonomial(entries[index][1].div(coeff), entries[index][0]);
|
|
60
|
+
return { term, coeff };
|
|
61
|
+
}
|
|
62
|
+
}
|
|
@@ -0,0 +1,91 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/lp_settings.h, src/math/lp/lp_settings.cpp), MIT license, see
|
|
2
|
+
// z3-license.txt. The settings that theory_lra's UFNIA configuration gives the lp solver, its
|
|
3
|
+
// random generator and its statistics.
|
|
4
|
+
import { RandomGen } from "../random-gen";
|
|
5
|
+
|
|
6
|
+
export interface LpStats {
|
|
7
|
+
makeFeasible: number;
|
|
8
|
+
pivots: number;
|
|
9
|
+
patches: number;
|
|
10
|
+
patchesSuccess: number;
|
|
11
|
+
gcdCalls: number;
|
|
12
|
+
gcdConflicts: number;
|
|
13
|
+
branches: number;
|
|
14
|
+
bpRowsAnalyzed: number;
|
|
15
|
+
offsetEqs: number;
|
|
16
|
+
fixedEqs: number;
|
|
17
|
+
dioCalls: number;
|
|
18
|
+
dioTightenConflicts: number;
|
|
19
|
+
dioRewriteConflicts: number;
|
|
20
|
+
dioStateResets: number;
|
|
21
|
+
lcubeCalls: number;
|
|
22
|
+
lcubeSuccess: number;
|
|
23
|
+
lcubeFlipSuccess: number;
|
|
24
|
+
nlaCalls: number;
|
|
25
|
+
nlaAddBounds: number;
|
|
26
|
+
nlaPropagateBounds: number;
|
|
27
|
+
nlaPropagateEq: number;
|
|
28
|
+
nlaLemmas: number;
|
|
29
|
+
nlaBoundsImprovements: number;
|
|
30
|
+
nlaThrottledLemmas: number;
|
|
31
|
+
nraCalls: number;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
export class LpSettings {
|
|
35
|
+
private random = new RandomGen(0);
|
|
36
|
+
readonly stats: LpStats = {
|
|
37
|
+
makeFeasible: 0,
|
|
38
|
+
pivots: 0,
|
|
39
|
+
patches: 0,
|
|
40
|
+
patchesSuccess: 0,
|
|
41
|
+
gcdCalls: 0,
|
|
42
|
+
gcdConflicts: 0,
|
|
43
|
+
branches: 0,
|
|
44
|
+
bpRowsAnalyzed: 0,
|
|
45
|
+
offsetEqs: 0,
|
|
46
|
+
fixedEqs: 0,
|
|
47
|
+
dioCalls: 0,
|
|
48
|
+
dioTightenConflicts: 0,
|
|
49
|
+
dioRewriteConflicts: 0,
|
|
50
|
+
dioStateResets: 0,
|
|
51
|
+
lcubeCalls: 0,
|
|
52
|
+
lcubeSuccess: 0,
|
|
53
|
+
lcubeFlipSuccess: 0,
|
|
54
|
+
nlaCalls: 0,
|
|
55
|
+
nlaAddBounds: 0,
|
|
56
|
+
nlaPropagateBounds: 0,
|
|
57
|
+
nlaPropagateEq: 0,
|
|
58
|
+
nlaLemmas: 0,
|
|
59
|
+
nlaBoundsImprovements: 0,
|
|
60
|
+
nlaThrottledLemmas: 0,
|
|
61
|
+
nraCalls: 0,
|
|
62
|
+
};
|
|
63
|
+
readonly maxRowLengthForBoundPropagation = 300;
|
|
64
|
+
readonly maxIterationsWithNoImprovements = 2000000;
|
|
65
|
+
readonly isPropagatingEqs = true;
|
|
66
|
+
readonly intFindCubePeriod = 4;
|
|
67
|
+
// lp.lcube_flips: the most flips that repair a rounded cube center.
|
|
68
|
+
readonly lcubeFlips = 16;
|
|
69
|
+
readonly hnfCutPeriod = 4;
|
|
70
|
+
readonly limitOnRowsForHnfCutter = 75;
|
|
71
|
+
readonly limitOnColumnsForHnfCutter = 150;
|
|
72
|
+
readonly intGomoryCutPeriod = 4;
|
|
73
|
+
// lp.dio_calls_period, which the Diophantine solver's results move, its decrease, and
|
|
74
|
+
// lp.dio_gomory_enable_period.
|
|
75
|
+
dioCallsPeriod = 1;
|
|
76
|
+
readonly dioCallsPeriodDecrease = 2;
|
|
77
|
+
readonly dioGomoryEnablePeriod = 16;
|
|
78
|
+
// m_run_gomory_with_dio: Gomory cuts run once the Diophantine solver keeps failing.
|
|
79
|
+
isRunningGomoryWithDio = false;
|
|
80
|
+
// lp.dio_ignore_big_nums and lp.dio_undo_max_work.
|
|
81
|
+
readonly isDioIgnoringBigNums = true;
|
|
82
|
+
readonly dioUndoMaxWork = 1000000;
|
|
83
|
+
|
|
84
|
+
constructor(readonly isCanceled: () => boolean) {}
|
|
85
|
+
|
|
86
|
+
// random_next: random_gen's next value, or that value modulo a bound.
|
|
87
|
+
getRandomNext(bound?: number) {
|
|
88
|
+
const value = this.random.next();
|
|
89
|
+
return bound === undefined ? value : value % bound;
|
|
90
|
+
}
|
|
91
|
+
}
|
|
@@ -0,0 +1,347 @@
|
|
|
1
|
+
// Ported from Z3 (maximize_term and its helpers in src/math/lp/lar_solver.cpp, and the tableau
|
|
2
|
+
// part of src/math/lp/lp_primal_core_solver.h, src/math/lp/lp_primal_core_solver_def.h,
|
|
3
|
+
// src/math/lp/lp_primal_core_solver_tableau_def.h), MIT license, see z3-license.txt. The primal
|
|
4
|
+
// simplex with the tableau_costs strategy: from a feasible solution, a non-basic column whose
|
|
5
|
+
// reduced cost improves the objective enters, the ratio test picks the basic column that leaves,
|
|
6
|
+
// and the reduced costs follow every pivot.
|
|
7
|
+
import { Rational } from "../rational";
|
|
8
|
+
import {
|
|
9
|
+
COLUMN_BOXED,
|
|
10
|
+
COLUMN_FIXED,
|
|
11
|
+
COLUMN_FREE,
|
|
12
|
+
COLUMN_LOWER,
|
|
13
|
+
COLUMN_UPPER,
|
|
14
|
+
type CoreSolver,
|
|
15
|
+
LP_CANCELLED,
|
|
16
|
+
LP_FEASIBLE,
|
|
17
|
+
LP_INFEASIBLE,
|
|
18
|
+
LP_OPTIMAL,
|
|
19
|
+
LP_UNBOUNDED,
|
|
20
|
+
} from "./core-solver";
|
|
21
|
+
import type { LarSolver } from "./lar-solver";
|
|
22
|
+
import { LarTerm } from "./lar-term";
|
|
23
|
+
import { Impq } from "./numeric-pair";
|
|
24
|
+
|
|
25
|
+
// m_nbasis_sort_counter: the non-basic columns are sorted again after this many choices.
|
|
26
|
+
const NBASIS_SORT_PERIOD = 20;
|
|
27
|
+
// percent_of_entering_to_check, for more than 300 non-basic columns.
|
|
28
|
+
const PERCENT_OF_ENTERING_TO_CHECK = 5;
|
|
29
|
+
|
|
30
|
+
// The theta of a ratio test, and whether a bound limits it yet.
|
|
31
|
+
interface ThetaLimit {
|
|
32
|
+
theta: Impq;
|
|
33
|
+
isUnlimited: boolean;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
const limitTheta = (limit: ThetaLimit, value: Impq) => {
|
|
37
|
+
if (limit.isUnlimited) {
|
|
38
|
+
limit.theta = value;
|
|
39
|
+
limit.isUnlimited = false;
|
|
40
|
+
} else if (value.compare(limit.theta) < 0) limit.theta = value;
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
const clampTheta = (limit: ThetaLimit) => {
|
|
44
|
+
if (limit.theta.compare(Impq.zero) < 0) limit.theta = Impq.zero;
|
|
45
|
+
};
|
|
46
|
+
|
|
47
|
+
const stopAtZero = (limit: ThetaLimit) => {
|
|
48
|
+
limit.theta = Impq.zero;
|
|
49
|
+
limit.isUnlimited = false;
|
|
50
|
+
};
|
|
51
|
+
|
|
52
|
+
class CostsSimplex {
|
|
53
|
+
private sortCounter = 0;
|
|
54
|
+
private nonBasisList: number[] = [];
|
|
55
|
+
private signOfEnteringDelta = 1;
|
|
56
|
+
|
|
57
|
+
constructor(
|
|
58
|
+
private readonly core: CoreSolver,
|
|
59
|
+
private readonly reducedCosts: Rational[],
|
|
60
|
+
) {}
|
|
61
|
+
|
|
62
|
+
// lar_core_solver::solve and lp_primal_core_solver::solve, not only looking for a feasible
|
|
63
|
+
// solution.
|
|
64
|
+
solve() {
|
|
65
|
+
const core = this.core;
|
|
66
|
+
const settings = core.settings;
|
|
67
|
+
core.status = LP_FEASIBLE;
|
|
68
|
+
do {
|
|
69
|
+
if (settings.isCanceled()) {
|
|
70
|
+
core.status = LP_CANCELLED;
|
|
71
|
+
return;
|
|
72
|
+
}
|
|
73
|
+
this.oneIteration();
|
|
74
|
+
if (settings.isCanceled()) {
|
|
75
|
+
core.status = LP_CANCELLED;
|
|
76
|
+
return;
|
|
77
|
+
}
|
|
78
|
+
} while (
|
|
79
|
+
core.status !== LP_UNBOUNDED &&
|
|
80
|
+
core.status !== LP_OPTIMAL &&
|
|
81
|
+
core.status !== LP_INFEASIBLE
|
|
82
|
+
);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
// one_iteration_tableau.
|
|
86
|
+
private oneIteration() {
|
|
87
|
+
const core = this.core;
|
|
88
|
+
const entering = this.chooseEntering();
|
|
89
|
+
if (entering === -1) {
|
|
90
|
+
core.status = core.isFeasible() ? LP_OPTIMAL : LP_INFEASIBLE;
|
|
91
|
+
return;
|
|
92
|
+
}
|
|
93
|
+
const limit: ThetaLimit = { theta: Impq.zero, isUnlimited: true };
|
|
94
|
+
const leaving = this.findLeaving(entering, limit);
|
|
95
|
+
if (leaving === -1) {
|
|
96
|
+
core.status = LP_UNBOUNDED;
|
|
97
|
+
return;
|
|
98
|
+
}
|
|
99
|
+
this.advance(entering, leaving, limit.theta);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
// sort_non_basis: the non-basic columns by the size of their columns, the empty ones last.
|
|
103
|
+
private sortNonBasis() {
|
|
104
|
+
const core = this.core;
|
|
105
|
+
const columns = core.matrix.columns;
|
|
106
|
+
core.nbasis.sort((first, second) => {
|
|
107
|
+
const firstSize = columns[first].length;
|
|
108
|
+
const secondSize = columns[second].length;
|
|
109
|
+
if (firstSize === 0 && secondSize !== 0) return 1;
|
|
110
|
+
if (firstSize !== 0 && secondSize === 0) return -1;
|
|
111
|
+
return firstSize !== secondSize ? firstSize - secondSize : first - second;
|
|
112
|
+
});
|
|
113
|
+
this.nonBasisList = core.nbasis.slice();
|
|
114
|
+
for (let index = 0; index < core.nbasis.length; index++)
|
|
115
|
+
core.heading[core.nbasis[index]] = -index - 1;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
// get_number_of_non_basic_column_to_try_for_enter.
|
|
119
|
+
private getNumberToTry() {
|
|
120
|
+
const count = this.core.nbasis.length;
|
|
121
|
+
const scaled = count > 300 ? Math.floor((count * PERCENT_OF_ENTERING_TO_CHECK) / 100) : count;
|
|
122
|
+
if (scaled === 0) return 0;
|
|
123
|
+
return Math.max(this.core.settings.getRandomNext() % scaled, 1);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
// choose_entering_column_tableau: among the first beneficial columns, the one with the fewest
|
|
127
|
+
// cells, and a random one among ties. It moves to the end of the list.
|
|
128
|
+
private chooseEntering() {
|
|
129
|
+
const core = this.core;
|
|
130
|
+
if (this.sortCounter === 0) {
|
|
131
|
+
this.sortNonBasis();
|
|
132
|
+
this.sortCounter = NBASIS_SORT_PERIOD;
|
|
133
|
+
} else this.sortCounter--;
|
|
134
|
+
let numToGoOver = this.getNumberToTry();
|
|
135
|
+
if (numToGoOver === 0) return -1;
|
|
136
|
+
let minCells = core.matrix.getRowCount() + 1;
|
|
137
|
+
let enteringIndex = -1;
|
|
138
|
+
let numTies = 0;
|
|
139
|
+
const list = this.nonBasisList;
|
|
140
|
+
for (let index = 0; numToGoOver > 0 && index < list.length; index++) {
|
|
141
|
+
const column = list[index];
|
|
142
|
+
if (!this.isBeneficial(column)) continue;
|
|
143
|
+
const cells = core.matrix.columns[column].length;
|
|
144
|
+
if (cells < minCells) {
|
|
145
|
+
minCells = cells;
|
|
146
|
+
enteringIndex = index;
|
|
147
|
+
numToGoOver--;
|
|
148
|
+
numTies = 1;
|
|
149
|
+
} else if (cells === minCells && core.settings.getRandomNext(++numTies) === 0)
|
|
150
|
+
enteringIndex = index;
|
|
151
|
+
}
|
|
152
|
+
if (enteringIndex === -1) return -1;
|
|
153
|
+
const entering = list[enteringIndex];
|
|
154
|
+
this.signOfEnteringDelta = this.reducedCosts[entering].isPositive() ? 1 : -1;
|
|
155
|
+
list.splice(enteringIndex, 1);
|
|
156
|
+
list.push(entering);
|
|
157
|
+
return entering;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
// column_is_benefitial_for_entering_basis.
|
|
161
|
+
private isBeneficial(column: number) {
|
|
162
|
+
const core = this.core;
|
|
163
|
+
const reducedCost = this.reducedCosts[column];
|
|
164
|
+
if (reducedCost.isZero()) return false;
|
|
165
|
+
switch (core.getColumnType(column)) {
|
|
166
|
+
case COLUMN_FREE:
|
|
167
|
+
return true;
|
|
168
|
+
case COLUMN_LOWER:
|
|
169
|
+
return reducedCost.isPositive();
|
|
170
|
+
case COLUMN_UPPER:
|
|
171
|
+
return reducedCost.isNegative();
|
|
172
|
+
case COLUMN_BOXED:
|
|
173
|
+
return reducedCost.isPositive()
|
|
174
|
+
? core.x[column].equals(core.lowerBounds[column])
|
|
175
|
+
: core.x[column].equals(core.upperBounds[column]);
|
|
176
|
+
default:
|
|
177
|
+
return false;
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
// find_leaving_and_t_tableau: the basic column that the ratio test stops first, with ties
|
|
182
|
+
// broken by the shortest row and then at random, or the entering column itself when it reaches
|
|
183
|
+
// its other bound first.
|
|
184
|
+
private findLeaving(entering: number, limit: ThetaLimit) {
|
|
185
|
+
const core = this.core;
|
|
186
|
+
const matrix = core.matrix;
|
|
187
|
+
const column = matrix.columns[entering];
|
|
188
|
+
const sign = Rational.fromNumber(this.signOfEnteringDelta);
|
|
189
|
+
let candidates: number[] = [];
|
|
190
|
+
let minRowCells = matrix.getColumnCount() + 1;
|
|
191
|
+
let index = 0;
|
|
192
|
+
for (; index < column.length && limit.isUnlimited; index++) {
|
|
193
|
+
const cell = column[index];
|
|
194
|
+
const basic = core.basis[cell.row];
|
|
195
|
+
this.limitThetaOnBasisColumn(basic, matrix.getVal(cell).neg().mul(sign), limit);
|
|
196
|
+
if (limit.isUnlimited) continue;
|
|
197
|
+
candidates.push(basic);
|
|
198
|
+
minRowCells = matrix.rows[cell.row].length;
|
|
199
|
+
}
|
|
200
|
+
if (limit.isUnlimited) {
|
|
201
|
+
if (core.getColumnType(entering) !== COLUMN_BOXED) return -1;
|
|
202
|
+
limit.theta =
|
|
203
|
+
this.signOfEnteringDelta > 0
|
|
204
|
+
? core.upperBounds[entering].sub(core.x[entering])
|
|
205
|
+
: core.x[entering].sub(core.lowerBounds[entering]);
|
|
206
|
+
return entering;
|
|
207
|
+
}
|
|
208
|
+
for (; index < column.length; index++) {
|
|
209
|
+
const cell = column[index];
|
|
210
|
+
const basic = core.basis[cell.row];
|
|
211
|
+
const ratio: ThetaLimit = { theta: Impq.zero, isUnlimited: true };
|
|
212
|
+
this.limitThetaOnBasisColumn(basic, matrix.getVal(cell).neg().mul(sign), ratio);
|
|
213
|
+
if (ratio.isUnlimited) continue;
|
|
214
|
+
const rowCells = matrix.rows[cell.row].length;
|
|
215
|
+
const comparison = ratio.theta.compare(limit.theta);
|
|
216
|
+
if (comparison < 0) {
|
|
217
|
+
limit.theta = ratio.theta;
|
|
218
|
+
candidates = [basic];
|
|
219
|
+
minRowCells = rowCells;
|
|
220
|
+
} else if (comparison === 0 && rowCells < minRowCells) {
|
|
221
|
+
candidates = [basic];
|
|
222
|
+
minRowCells = rowCells;
|
|
223
|
+
} else if (comparison === 0 && rowCells === minRowCells) candidates.push(basic);
|
|
224
|
+
}
|
|
225
|
+
if (core.getColumnType(entering) === COLUMN_BOXED) {
|
|
226
|
+
const span = core.upperBounds[entering].sub(core.lowerBounds[entering]);
|
|
227
|
+
if (span.compare(limit.theta) <= 0) {
|
|
228
|
+
limit.theta = span;
|
|
229
|
+
return entering;
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
if (candidates.length === 1) return candidates[0];
|
|
233
|
+
return candidates[core.settings.getRandomNext() % candidates.length];
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
// limit_theta_on_basis_column: x[basic] + theta * m stays within the bounds of the column, or
|
|
237
|
+
// moves toward them when it is outside.
|
|
238
|
+
private limitThetaOnBasisColumn(basic: number, m: Rational, limit: ThetaLimit) {
|
|
239
|
+
const core = this.core;
|
|
240
|
+
const x = core.x[basic];
|
|
241
|
+
const lower = core.lowerBounds[basic];
|
|
242
|
+
const upper = core.upperBounds[basic];
|
|
243
|
+
const isFeasible = core.isFeasible();
|
|
244
|
+
const limitBy = (bound: Impq) => limitTheta(limit, bound.sub(x).div(m));
|
|
245
|
+
const limitFeasibly = (bound: Impq) => {
|
|
246
|
+
limitBy(bound);
|
|
247
|
+
clampTheta(limit);
|
|
248
|
+
};
|
|
249
|
+
switch (core.getColumnType(basic)) {
|
|
250
|
+
case COLUMN_FREE:
|
|
251
|
+
break;
|
|
252
|
+
case COLUMN_UPPER:
|
|
253
|
+
if (isFeasible) {
|
|
254
|
+
if (m.isPositive()) limitFeasibly(upper);
|
|
255
|
+
} else if (m.isPositive()) {
|
|
256
|
+
if (x.compare(upper) < 0) limitBy(upper);
|
|
257
|
+
else if (x.compare(upper) === 0) stopAtZero(limit);
|
|
258
|
+
} else if (x.compare(upper) > 0) limitBy(upper);
|
|
259
|
+
break;
|
|
260
|
+
case COLUMN_LOWER:
|
|
261
|
+
if (isFeasible) {
|
|
262
|
+
if (m.isNegative()) limitFeasibly(lower);
|
|
263
|
+
} else if (m.isNegative()) {
|
|
264
|
+
if (x.compare(lower) > 0) limitBy(lower);
|
|
265
|
+
else if (x.compare(lower) === 0) stopAtZero(limit);
|
|
266
|
+
} else if (x.compare(lower) < 0) limitBy(lower);
|
|
267
|
+
break;
|
|
268
|
+
case COLUMN_FIXED:
|
|
269
|
+
case COLUMN_BOXED:
|
|
270
|
+
if (isFeasible) limitFeasibly(m.isPositive() ? upper : lower);
|
|
271
|
+
else if (m.isPositive()) {
|
|
272
|
+
if (x.compare(lower) < 0) limitBy(lower);
|
|
273
|
+
else if (x.compare(upper) < 0) limitBy(upper);
|
|
274
|
+
else if (x.compare(upper) <= 0) stopAtZero(limit);
|
|
275
|
+
} else if (x.compare(upper) > 0) limitBy(upper);
|
|
276
|
+
else if (x.compare(lower) > 0) limitBy(lower);
|
|
277
|
+
else if (x.compare(lower) >= 0) stopAtZero(limit);
|
|
278
|
+
break;
|
|
279
|
+
}
|
|
280
|
+
if (!limit.isUnlimited) clampTheta(limit);
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
// advance_on_entering_and_leaving_tableau.
|
|
284
|
+
private advance(entering: number, leaving: number, theta: Impq) {
|
|
285
|
+
const core = this.core;
|
|
286
|
+
const sign = Rational.fromNumber(this.signOfEnteringDelta);
|
|
287
|
+
if (entering === leaving) {
|
|
288
|
+
this.updateX(entering, theta.mul(sign));
|
|
289
|
+
return;
|
|
290
|
+
}
|
|
291
|
+
if (!theta.isZero()) this.updateX(entering, core.isFeasible() ? theta.mul(sign) : theta);
|
|
292
|
+
core.pivot(entering, leaving);
|
|
293
|
+
this.nonBasisList[this.nonBasisList.length - 1] = leaving;
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
// update_x_tableau.
|
|
297
|
+
private updateX(entering: number, delta: Impq) {
|
|
298
|
+
const core = this.core;
|
|
299
|
+
core.x[entering] = core.x[entering].add(delta);
|
|
300
|
+
for (const cell of core.matrix.columns[entering])
|
|
301
|
+
core.addDeltaToXAndTrackFeasibility(
|
|
302
|
+
core.basis[cell.row],
|
|
303
|
+
delta.mul(core.matrix.getVal(cell)).neg(),
|
|
304
|
+
);
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
// maximize_term_on_feasible_r_solver: the costs of the term and their reduced costs, the simplex,
|
|
309
|
+
// and the term's value at the optimum, or undefined when it is unbounded or cancelled.
|
|
310
|
+
const maximizeOnFeasibleSolver = (solver: LarSolver, term: LarTerm) => {
|
|
311
|
+
const core = solver.core;
|
|
312
|
+
solver.moveNonBasicColumnsToBounds();
|
|
313
|
+
const reducedCosts = core.x.map(() => Rational.zero);
|
|
314
|
+
for (const entry of term.coeffs) {
|
|
315
|
+
const column = entry[0];
|
|
316
|
+
const rowIndex = core.heading[column];
|
|
317
|
+
if (rowIndex < 0) {
|
|
318
|
+
reducedCosts[column] = reducedCosts[column].add(entry[1]);
|
|
319
|
+
continue;
|
|
320
|
+
}
|
|
321
|
+
for (const cell of core.matrix.rows[rowIndex])
|
|
322
|
+
if (cell.column !== column)
|
|
323
|
+
reducedCosts[cell.column] = reducedCosts[cell.column].sub(entry[1].mul(cell.coeff));
|
|
324
|
+
}
|
|
325
|
+
core.reducedCosts = reducedCosts;
|
|
326
|
+
new CostsSimplex(core, reducedCosts).solve();
|
|
327
|
+
core.reducedCosts = undefined;
|
|
328
|
+
const status = core.status;
|
|
329
|
+
core.status = LP_OPTIMAL;
|
|
330
|
+
return status === LP_UNBOUNDED || status === LP_CANCELLED ? undefined : term.apply(core.x);
|
|
331
|
+
};
|
|
332
|
+
|
|
333
|
+
// maximize_term without fixing the integer columns: the maximum of the column or of its term, or
|
|
334
|
+
// undefined, with the values restored, when it is unbounded.
|
|
335
|
+
export const maximizeTerm = (solver: LarSolver, column: number) => {
|
|
336
|
+
const term = solver.hasTerm(column)
|
|
337
|
+
? solver.getTerm(column)
|
|
338
|
+
: new LarTerm([[column, Rational.one]]);
|
|
339
|
+
const backup = solver.core.x.slice();
|
|
340
|
+
const maximum = maximizeOnFeasibleSolver(solver, term);
|
|
341
|
+
if (maximum === undefined) {
|
|
342
|
+
solver.core.x.splice(0, backup.length, ...backup);
|
|
343
|
+
return undefined;
|
|
344
|
+
}
|
|
345
|
+
solver.status = LP_OPTIMAL;
|
|
346
|
+
return maximum;
|
|
347
|
+
};
|