tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.68b2c4968
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 +2 -1
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +45 -41
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +4 -1
- package/dist/index.d.ts +4 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2682 -426
- package/dist/prove.js +2679 -423
- package/dist/run.cjs +43 -42
- package/dist/run.js +44 -43
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +1 -1
- package/dist/transfer.cjs +44 -41
- package/dist/transfer.js +43 -40
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +349 -91
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlapm.ts +424 -62
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +4 -5
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +26 -7
- package/src/codegen.ts +6 -2
- package/src/dependencies.ts +72 -11
- package/src/dfid.ts +9 -2
- package/src/environment.ts +27 -5
- package/src/errors.ts +38 -3
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +1 -1
- package/src/levels.ts +134 -86
- package/src/lexer.ts +5 -3
- package/src/liveness-checker.ts +572 -204
- package/src/liveness.ts +47 -32
- package/src/obligations/action.ts +10 -6
- package/src/obligations/anonymize.ts +33 -14
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +18 -6
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +22 -17
- package/src/obligations/index.ts +36 -6
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +1 -3
- package/src/obligations/normalize.ts +24 -13
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +43 -13
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +17 -7
- package/src/obligations/source.ts +71 -17
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +7 -2
- package/src/parser.ts +634 -186
- package/src/pretty-print.ts +1 -1
- package/src/prover/deciders.ts +11 -8
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +71 -41
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
- package/src/prover/isabelle/isar/method.ts +506 -198
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +479 -69
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +83 -8
- package/src/prover/isabelle/provers/blast/blast.ts +0 -2
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +2 -4
- package/src/prover/isabelle/pure/bicompose.ts +0 -2
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +0 -2
- package/src/prover/isabelle/pure/drule.ts +63 -4
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +0 -2
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
- package/src/prover/isabelle/pure/rewriter.ts +1 -8
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +0 -2
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +0 -2
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +0 -2
- package/src/prover/isabelle/pure/thm.ts +0 -2
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +1 -2
- package/src/prover/isabelle/tla/context.ts +51 -9
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +40 -1
- package/src/prover/isabelle/tla/simpdata.ts +0 -2
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +19 -12
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/methods.ts +159 -50
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +343 -65
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +42 -6
- package/src/prover/smt/data.ts +191 -84
- package/src/prover/smt/encode.ts +122 -43
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +483 -116
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +613 -6
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/asserted-formulas.ts +93 -15
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1449 -41
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +109 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +533 -114
- package/src/prover/smt/solver/ctx-simplify.ts +21 -12
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +205 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +6 -7
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +267 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +177 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +30 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +109 -36
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +18 -3
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +66 -11
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +118 -88
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +17 -26
- package/src/prover/smt/solver/model-evaluator.ts +188 -12
- package/src/prover/smt/solver/model-finder.ts +0 -1
- package/src/prover/smt/solver/model-generator.ts +59 -30
- package/src/prover/smt/solver/model-macro-solver.ts +38 -27
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +410 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +424 -211
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
- package/src/prover/smt/solver/nlsat/solver.ts +282 -69
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +105 -23
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +792 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +311 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +202 -57
- package/src/prover/smt/solver/probes.ts +511 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +650 -17
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +37 -17
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
- package/src/prover/smt/solver/quantifier-manager.ts +25 -24
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
- package/src/prover/smt/solver/rewriter.ts +475 -36
- package/src/prover/smt/solver/rlimit.ts +38 -2
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2105 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +90 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +544 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
- package/src/prover/smt/solver/smtlib-script.ts +1843 -0
- package/src/prover/smt/solver/solve-eqs.ts +923 -0
- package/src/prover/smt/solver/solver.ts +113 -22
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2012 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
- package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
- package/src/prover/smt/solver/theory-lra-state.ts +6 -22
- package/src/prover/smt/solver/theory-lra.ts +188 -2
- package/src/prover/smt/solver/theory-pb.ts +933 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +29 -8
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +2 -0
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +0 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +21 -2
- package/src/prover/zenon/index-table.ts +7 -4
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +2 -4
- package/src/prover/zenon/llproof.ts +0 -2
- package/src/prover/zenon/mltoll.ts +0 -2
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +6 -2
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +7 -5
- package/src/prover/zenon/tla/functions.ts +0 -2
- package/src/prover/zenon/tla/llproof.ts +0 -2
- package/src/prover/zenon/tla/records.ts +0 -2
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +7 -8
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +0 -2
- package/src/resolve.ts +264 -77
- package/src/runtime.ts +6 -0
- package/src/sany/generation.ts +1 -13
- package/src/sany/generator-definitions.ts +2 -1
- package/src/sany/generator-expressions.ts +30 -27
- package/src/sany/generator-proofs.ts +1 -1
- package/src/sany/generator.ts +2 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/linter.ts +0 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +6 -5
- package/src/search.ts +209 -56
- package/src/simulate.ts +3 -0
- package/src/spec-description.ts +2 -2
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +165 -78
- package/src/successors.ts +2 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +12 -0
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +2 -3
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +42 -23
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -0,0 +1,2251 @@
|
|
|
1
|
+
// A statement that discards its result builds a term that upstream builds and never uses, so the
|
|
2
|
+
// terms after it get the ids Z3 gives them.
|
|
3
|
+
import { SmtCanceledError, SmtUnsupportedError } from "../../../errors";
|
|
4
|
+
import {
|
|
5
|
+
type AstManager,
|
|
6
|
+
OP_BADD,
|
|
7
|
+
OP_BAND,
|
|
8
|
+
OP_BASHR,
|
|
9
|
+
OP_BLSHR,
|
|
10
|
+
OP_BMUL,
|
|
11
|
+
OP_BNEG,
|
|
12
|
+
OP_BNOT,
|
|
13
|
+
OP_BOR,
|
|
14
|
+
OP_BREDAND,
|
|
15
|
+
OP_BREDOR,
|
|
16
|
+
OP_BSHL,
|
|
17
|
+
OP_BSUB,
|
|
18
|
+
OP_BUDIV_I,
|
|
19
|
+
OP_BUREM,
|
|
20
|
+
OP_BXOR,
|
|
21
|
+
OP_CONCAT,
|
|
22
|
+
OP_EXTRACT,
|
|
23
|
+
OP_FPA_BV2RM,
|
|
24
|
+
OP_FPA_BVWRAP,
|
|
25
|
+
OP_FPA_FP,
|
|
26
|
+
OP_FPA_MAX,
|
|
27
|
+
OP_FPA_MIN,
|
|
28
|
+
OP_FPA_TO_REAL,
|
|
29
|
+
OP_ITE,
|
|
30
|
+
OP_ADD,
|
|
31
|
+
OP_DIV,
|
|
32
|
+
OP_GE,
|
|
33
|
+
OP_GT,
|
|
34
|
+
OP_IMPLIES,
|
|
35
|
+
OP_LE,
|
|
36
|
+
OP_LT,
|
|
37
|
+
OP_MUL,
|
|
38
|
+
OP_POWER,
|
|
39
|
+
OP_SUB,
|
|
40
|
+
OP_TO_REAL,
|
|
41
|
+
OP_UMINUS,
|
|
42
|
+
OP_SIGN_EXT,
|
|
43
|
+
OP_SLEQ,
|
|
44
|
+
OP_SLT,
|
|
45
|
+
OP_ULEQ,
|
|
46
|
+
OP_ZERO_EXT,
|
|
47
|
+
OP_NUM,
|
|
48
|
+
SORT_BOOL,
|
|
49
|
+
SORT_INT,
|
|
50
|
+
SORT_REAL,
|
|
51
|
+
} from "./ast";
|
|
52
|
+
import { mkBvApp } from "./bv-decl-plugin";
|
|
53
|
+
import {
|
|
54
|
+
BV_RM_TIES_TO_AWAY,
|
|
55
|
+
BV_RM_TIES_TO_EVEN,
|
|
56
|
+
BV_RM_TO_NEGATIVE,
|
|
57
|
+
BV_RM_TO_POSITIVE,
|
|
58
|
+
BV_RM_TO_ZERO,
|
|
59
|
+
getFpNumeral,
|
|
60
|
+
mkFpaApp,
|
|
61
|
+
mkRmNumeral,
|
|
62
|
+
} from "./fpa-decl-plugin";
|
|
63
|
+
import { ObjMap } from "./hashtable";
|
|
64
|
+
import { isInf, isNan, type Mpf, mpfFromRational } from "./mpf";
|
|
65
|
+
import { Rational } from "./rational";
|
|
66
|
+
import { RefVector } from "./ref-vector";
|
|
67
|
+
import type { Rewriter } from "./rewriter";
|
|
68
|
+
|
|
69
|
+
const getLog2 = (value: number) => (value > 0 ? 31 - Math.clz32(value) : 0);
|
|
70
|
+
|
|
71
|
+
const getBigLog2 = (value: bigint) => (value > 0n ? value.toString(2).length - 1 : 0);
|
|
72
|
+
|
|
73
|
+
const getPowerOfTwoMinusOne = (exponent: number) => (1n << BigInt(exponent)) - 1n;
|
|
74
|
+
|
|
75
|
+
interface Unpacked {
|
|
76
|
+
sgn: number;
|
|
77
|
+
sig: number;
|
|
78
|
+
exp: number;
|
|
79
|
+
lz: number;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
export class Fpa2BvConverter {
|
|
83
|
+
readonly constants: ObjMap<number>;
|
|
84
|
+
readonly rmConstants: ObjMap<number>;
|
|
85
|
+
readonly minMaxUfs: ObjMap<[number, number]>;
|
|
86
|
+
readonly uf2BvUf: ObjMap<number>;
|
|
87
|
+
readonly extraAssertions: RefVector;
|
|
88
|
+
|
|
89
|
+
constructor(
|
|
90
|
+
protected manager: AstManager,
|
|
91
|
+
private simp: Rewriter,
|
|
92
|
+
) {
|
|
93
|
+
const getHash = (decl: number) => manager.getDeclHash(decl);
|
|
94
|
+
this.constants = new ObjMap(getHash);
|
|
95
|
+
this.rmConstants = new ObjMap(getHash);
|
|
96
|
+
this.minMaxUfs = new ObjMap(getHash);
|
|
97
|
+
this.uf2BvUf = new ObjMap(getHash);
|
|
98
|
+
this.extraAssertions = new RefVector(manager);
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
reset() {
|
|
102
|
+
const manager = this.manager;
|
|
103
|
+
for (const entry of [...this.constants, ...this.rmConstants]) {
|
|
104
|
+
manager.decDeclRef(entry[0]);
|
|
105
|
+
manager.decRef(entry[1]);
|
|
106
|
+
}
|
|
107
|
+
for (const entry of this.uf2BvUf) {
|
|
108
|
+
manager.decDeclRef(entry[0]);
|
|
109
|
+
manager.decDeclRef(entry[1]);
|
|
110
|
+
}
|
|
111
|
+
for (const entry of this.minMaxUfs) {
|
|
112
|
+
manager.decDeclRef(entry[0]);
|
|
113
|
+
manager.decRef(entry[1][0]);
|
|
114
|
+
manager.decRef(entry[1][1]);
|
|
115
|
+
}
|
|
116
|
+
this.constants.clear();
|
|
117
|
+
this.rmConstants.clear();
|
|
118
|
+
this.minMaxUfs.clear();
|
|
119
|
+
this.uf2BvUf.clear();
|
|
120
|
+
this.extraAssertions.reset();
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
protected num(value: bigint | number, width: number) {
|
|
124
|
+
return this.manager.mkBvNumeral(BigInt(value), width);
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
protected bv(op: number, ...args: number[]) {
|
|
128
|
+
return mkBvApp(this.manager, op, args);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
protected extract(high: number, low: number, expr: number) {
|
|
132
|
+
return mkBvApp(this.manager, OP_EXTRACT, [expr], [high, low]);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
protected concat(...args: number[]) {
|
|
136
|
+
return mkBvApp(this.manager, OP_CONCAT, args);
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
private zeroExtend(amount: number, expr: number) {
|
|
140
|
+
return mkBvApp(this.manager, OP_ZERO_EXT, [expr], [amount]);
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
private signExtend(amount: number, expr: number) {
|
|
144
|
+
return mkBvApp(this.manager, OP_SIGN_EXT, [expr], [amount]);
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
protected getBvSize(expr: number) {
|
|
148
|
+
return this.manager.getBvSize(this.manager.sorts[expr]);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
mkFp(sgn: number, exp: number, sig: number) {
|
|
152
|
+
return mkFpaApp(this.manager, OP_FPA_FP, [sgn, exp, sig]);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
mkBv2Rm(expr: number) {
|
|
156
|
+
return mkFpaApp(this.manager, OP_FPA_BV2RM, [expr]);
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
private mkAnd(...args: number[]) {
|
|
160
|
+
return this.manager.mkAnd(args);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
private mkOr(...args: number[]) {
|
|
164
|
+
return this.manager.mkOr(args);
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
protected mkRawIte(condition: number, thenExpr: number, elseExpr: number) {
|
|
168
|
+
return this.manager.mkApp(
|
|
169
|
+
OP_ITE,
|
|
170
|
+
[condition, thenExpr, elseExpr],
|
|
171
|
+
this.manager.sorts[thenExpr],
|
|
172
|
+
);
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
private simpEq(left: number, right: number) {
|
|
176
|
+
return this.simp.mkEq(left, right);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
private simpNot(expr: number) {
|
|
180
|
+
return this.simp.mkNot(expr);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
private simpAnd(...args: number[]) {
|
|
184
|
+
return this.simp.mkAnd(args);
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
private simpOr(...args: number[]) {
|
|
188
|
+
return this.simp.mkOr(args);
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
private simpXor(first: number, second: number) {
|
|
192
|
+
return this.simp.mkEq(this.simp.mkNot(first), second);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
private simpIte(condition: number, thenExpr: number, elseExpr: number) {
|
|
196
|
+
const result = this.simp.mkIte(condition, thenExpr, elseExpr);
|
|
197
|
+
return typeof result === "number" ? result : result.expr;
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
private bvUlt(first: number, second: number) {
|
|
201
|
+
return this.simpNot(this.bv(OP_ULEQ, second, first));
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
isFp(expr: number) {
|
|
205
|
+
return this.manager.getOp(expr) === OP_FPA_FP;
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
splitFp(expr: number) {
|
|
209
|
+
const manager = this.manager;
|
|
210
|
+
return [manager.getArg(expr, 0), manager.getArg(expr, 1), manager.getArg(expr, 2)];
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
mkEq(first: number, second: number) {
|
|
214
|
+
const manager = this.manager;
|
|
215
|
+
if (manager.isFpSort(manager.sorts[first])) {
|
|
216
|
+
const eqSgn = this.simpEq(manager.getArg(first, 0), manager.getArg(second, 0));
|
|
217
|
+
const eqExp = this.simpEq(manager.getArg(first, 1), manager.getArg(second, 1));
|
|
218
|
+
const eqSig = this.simpEq(manager.getArg(first, 2), manager.getArg(second, 2));
|
|
219
|
+
const bothTheSame = this.simpAnd(eqSgn, eqExp, eqSig);
|
|
220
|
+
const firstIsNan = this.mkIsNan(first);
|
|
221
|
+
const secondIsNan = this.mkIsNan(second);
|
|
222
|
+
const bothAreNan = this.simpAnd(firstIsNan, secondIsNan);
|
|
223
|
+
return this.simpOr(bothAreNan, bothTheSame);
|
|
224
|
+
}
|
|
225
|
+
return this.simpEq(manager.getArg(first, 0), manager.getArg(second, 0));
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
mkIte(condition: number, thenExpr: number, elseExpr: number): number {
|
|
229
|
+
const manager = this.manager;
|
|
230
|
+
if (manager.getOp(thenExpr) === OP_ITE) {
|
|
231
|
+
const inner = this.mkIte(
|
|
232
|
+
manager.getArg(thenExpr, 0),
|
|
233
|
+
manager.getArg(thenExpr, 1),
|
|
234
|
+
manager.getArg(thenExpr, 2),
|
|
235
|
+
);
|
|
236
|
+
return this.mkIte(condition, inner, elseExpr);
|
|
237
|
+
}
|
|
238
|
+
if (manager.getOp(elseExpr) === OP_ITE) {
|
|
239
|
+
const inner = this.mkIte(
|
|
240
|
+
manager.getArg(elseExpr, 0),
|
|
241
|
+
manager.getArg(elseExpr, 1),
|
|
242
|
+
manager.getArg(elseExpr, 2),
|
|
243
|
+
);
|
|
244
|
+
return this.mkIte(condition, thenExpr, inner);
|
|
245
|
+
}
|
|
246
|
+
if (this.isFp(thenExpr) && this.isFp(elseExpr)) {
|
|
247
|
+
const sgn = this.simpIte(condition, manager.getArg(thenExpr, 0), manager.getArg(elseExpr, 0));
|
|
248
|
+
const sig = this.simpIte(condition, manager.getArg(thenExpr, 2), manager.getArg(elseExpr, 2));
|
|
249
|
+
const exp = this.simpIte(condition, manager.getArg(thenExpr, 1), manager.getArg(elseExpr, 1));
|
|
250
|
+
return this.mkFp(sgn, exp, sig);
|
|
251
|
+
}
|
|
252
|
+
return this.mkBv2Rm(
|
|
253
|
+
this.simpIte(condition, manager.getArg(thenExpr, 0), manager.getArg(elseExpr, 0)),
|
|
254
|
+
);
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
mkDistinct(args: number[]) {
|
|
258
|
+
let result = this.manager.trueExpr;
|
|
259
|
+
for (let first = 0; first < args.length; first++)
|
|
260
|
+
for (let second = first + 1; second < args.length; second++) {
|
|
261
|
+
const notEq = this.manager.mkNot(this.mkEq(args[first], args[second]));
|
|
262
|
+
result = this.simpAnd(result, notEq);
|
|
263
|
+
}
|
|
264
|
+
return result;
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
mkNumeral(sort: number, value: Mpf) {
|
|
268
|
+
if (isNan(value)) return this.mkNan(sort);
|
|
269
|
+
if (isInf(value)) return value.sign ? this.mkNinf(sort) : this.mkPinf(sort);
|
|
270
|
+
const bvSgn = this.num(value.sign ? 1 : 0, 1);
|
|
271
|
+
const bvSig = this.num(value.significand, value.sbits - 1);
|
|
272
|
+
const exponent = this.num(value.exponent, value.ebits);
|
|
273
|
+
return this.mkFp(bvSgn, this.mkBias(exponent), bvSig);
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
mkNumeralOf(expr: number) {
|
|
277
|
+
const value = getFpNumeral(this.manager, expr);
|
|
278
|
+
return value === undefined ? -1 : this.mkNumeral(this.manager.sorts[expr], value);
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
mkConst(decl: number) {
|
|
282
|
+
const existing = this.constants.get(decl);
|
|
283
|
+
if (existing !== undefined) return existing;
|
|
284
|
+
const manager = this.manager;
|
|
285
|
+
const sort = manager.funcDecls[decl].range;
|
|
286
|
+
const sbits = manager.getSbits(sort);
|
|
287
|
+
const size = manager.getEbits(sort) + sbits;
|
|
288
|
+
const bv = manager.mkFreshConst(null, manager.mkBvSort(size));
|
|
289
|
+
const sgn = this.extract(size - 1, size - 1, bv);
|
|
290
|
+
const exp = this.extract(size - 2, sbits - 1, bv);
|
|
291
|
+
const sig = this.extract(sbits - 2, 0, bv);
|
|
292
|
+
return this.cacheConst(this.constants, decl, this.mkFp(sgn, exp, sig));
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
protected cacheConst(cache: ObjMap<number>, decl: number, result: number) {
|
|
296
|
+
cache.set(decl, result);
|
|
297
|
+
this.manager.incDeclRef(decl);
|
|
298
|
+
this.manager.incRef(result);
|
|
299
|
+
return result;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
mkRmConst(decl: number) {
|
|
303
|
+
const existing = this.rmConstants.get(decl);
|
|
304
|
+
if (existing !== undefined) return existing;
|
|
305
|
+
const manager = this.manager;
|
|
306
|
+
const bv = manager.mkFreshConst(null, manager.mkBvSort(3));
|
|
307
|
+
const result = this.cacheConst(this.rmConstants, decl, this.mkBv2Rm(bv));
|
|
308
|
+
this.extraAssertions.push(this.bv(OP_ULEQ, bv, this.num(4, 3)));
|
|
309
|
+
return result;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
mkUf(decl: number, args: number[]) {
|
|
313
|
+
const manager = this.manager;
|
|
314
|
+
const range = manager.funcDecls[decl].range;
|
|
315
|
+
const isFloat = manager.isFpSort(range);
|
|
316
|
+
if (!isFloat && !manager.isRmSort(range)) return manager.mkApp(decl, args, range);
|
|
317
|
+
if (args.some((arg) => !manager.isGround(arg)))
|
|
318
|
+
throw new SmtUnsupportedError("floating-point functions under quantifiers");
|
|
319
|
+
const domain = args.map((arg) => manager.sorts[arg]);
|
|
320
|
+
const application = manager.mkApp(decl, args, range);
|
|
321
|
+
const size = isFloat ? manager.getEbits(range) + manager.getSbits(range) : 3;
|
|
322
|
+
const bvRange = manager.mkBvSort(size);
|
|
323
|
+
const bvApplication = manager.mkApp(this.mkBvUf(decl, domain, bvRange), args, bvRange);
|
|
324
|
+
const sbits = isFloat ? manager.getSbits(range) : 0;
|
|
325
|
+
const result = isFloat
|
|
326
|
+
? this.mkFp(
|
|
327
|
+
this.extract(size - 1, size - 1, bvApplication),
|
|
328
|
+
this.extract(size - 2, sbits - 1, bvApplication),
|
|
329
|
+
this.extract(sbits - 2, 0, bvApplication),
|
|
330
|
+
)
|
|
331
|
+
: this.mkBv2Rm(bvApplication);
|
|
332
|
+
this.extraAssertions.push(manager.mkEq(application, result));
|
|
333
|
+
return result;
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
mkRoundingMode(rm: number) {
|
|
337
|
+
return this.mkBv2Rm(this.num(rm, 3));
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
mkPinf(sort: number) {
|
|
341
|
+
const manager = this.manager;
|
|
342
|
+
const topExp = this.mkTopExp(manager.getEbits(sort));
|
|
343
|
+
const sgn = this.num(0, 1);
|
|
344
|
+
const sig = this.num(0, manager.getSbits(sort) - 1);
|
|
345
|
+
return this.mkFp(sgn, topExp, sig);
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
mkNinf(sort: number) {
|
|
349
|
+
const manager = this.manager;
|
|
350
|
+
const topExp = this.mkTopExp(manager.getEbits(sort));
|
|
351
|
+
const sgn = this.num(1, 1);
|
|
352
|
+
const sig = this.num(0, manager.getSbits(sort) - 1);
|
|
353
|
+
return this.mkFp(sgn, topExp, sig);
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
mkNan(sort: number) {
|
|
357
|
+
const manager = this.manager;
|
|
358
|
+
const topExp = this.mkTopExp(manager.getEbits(sort));
|
|
359
|
+
const sgn = this.num(0, 1);
|
|
360
|
+
const sig = this.num(1, manager.getSbits(sort) - 1);
|
|
361
|
+
return this.mkFp(sgn, topExp, sig);
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
mkNzero(sort: number) {
|
|
365
|
+
const manager = this.manager;
|
|
366
|
+
const botExp = this.mkBotExp(manager.getEbits(sort));
|
|
367
|
+
const sgn = this.num(1, 1);
|
|
368
|
+
const sig = this.num(0, manager.getSbits(sort) - 1);
|
|
369
|
+
return this.mkFp(sgn, botExp, sig);
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
mkPzero(sort: number) {
|
|
373
|
+
const manager = this.manager;
|
|
374
|
+
const botExp = this.mkBotExp(manager.getEbits(sort));
|
|
375
|
+
const sgn = this.num(0, 1);
|
|
376
|
+
const sig = this.num(0, manager.getSbits(sort) - 1);
|
|
377
|
+
return this.mkFp(sgn, botExp, sig);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
private mkOne(sort: number, sign: number) {
|
|
381
|
+
const manager = this.manager;
|
|
382
|
+
const ebits = manager.getEbits(sort);
|
|
383
|
+
const exp = this.num(getPowerOfTwoMinusOne(ebits - 1), ebits);
|
|
384
|
+
const sig = this.num(0, manager.getSbits(sort) - 1);
|
|
385
|
+
return this.mkFp(sign, exp, sig);
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
private addCore(
|
|
389
|
+
sbits: number,
|
|
390
|
+
ebits: number,
|
|
391
|
+
inputCSig: number,
|
|
392
|
+
cSgn: number,
|
|
393
|
+
cExp: number,
|
|
394
|
+
dSgn: number,
|
|
395
|
+
inputDSig: number,
|
|
396
|
+
dExp: number,
|
|
397
|
+
) {
|
|
398
|
+
const delta = this.bv(OP_BSUB, cExp, dExp);
|
|
399
|
+
let expDelta = delta;
|
|
400
|
+
if (getLog2(sbits + 2) < ebits + 2) {
|
|
401
|
+
const cap = this.num(sbits + 2, ebits + 2);
|
|
402
|
+
const capLeDelta = this.bv(OP_ULEQ, cap, this.zeroExtend(2, delta));
|
|
403
|
+
const expDeltaExt = this.zeroExtend(2, delta);
|
|
404
|
+
expDelta = this.extract(ebits - 1, 0, this.simpIte(capLeDelta, cap, expDeltaExt));
|
|
405
|
+
}
|
|
406
|
+
const cSig = this.concat(inputCSig, this.num(0, 3));
|
|
407
|
+
const dSig = this.concat(inputDSig, this.num(0, 3));
|
|
408
|
+
const bigDSig = this.concat(dSig, this.num(0, sbits + 3));
|
|
409
|
+
if (ebits > sbits) throw new SmtUnsupportedError("floating-point addition with ebits > sbits");
|
|
410
|
+
const shiftedBig = this.bv(
|
|
411
|
+
OP_BLSHR,
|
|
412
|
+
bigDSig,
|
|
413
|
+
this.concat(this.num(0, 2 * (sbits + 3) - ebits), expDelta),
|
|
414
|
+
);
|
|
415
|
+
const shiftedDSigRaw = this.extract(2 * (sbits + 3) - 1, sbits + 3, shiftedBig);
|
|
416
|
+
const stickyRaw = this.extract(sbits + 2, 0, shiftedBig);
|
|
417
|
+
const nilSbit3 = this.num(0, sbits + 3);
|
|
418
|
+
const oneSbit3 = this.num(1, sbits + 3);
|
|
419
|
+
const stickyEq = this.simpEq(stickyRaw, nilSbit3);
|
|
420
|
+
const sticky = this.simpIte(stickyEq, nilSbit3, oneSbit3);
|
|
421
|
+
const shiftedDSigOr = this.bv(OP_BOR, shiftedDSigRaw, sticky);
|
|
422
|
+
const eqSgn = this.simpEq(cSgn, dSgn);
|
|
423
|
+
const cSigExt = this.zeroExtend(2, cSig);
|
|
424
|
+
const shiftedDSig = this.zeroExtend(2, shiftedDSigOr);
|
|
425
|
+
const cPlusD = this.bv(OP_BADD, cSigExt, shiftedDSig);
|
|
426
|
+
const cMinusD = this.bv(OP_BSUB, cSigExt, shiftedDSig);
|
|
427
|
+
const sum = this.simpIte(eqSgn, cPlusD, cMinusD);
|
|
428
|
+
const signBv = this.extract(sbits + 4, sbits + 4, sum);
|
|
429
|
+
const nSum = this.bv(OP_BNEG, sum);
|
|
430
|
+
const notCSgn = this.bv(OP_BNOT, cSgn);
|
|
431
|
+
const notDSgn = this.bv(OP_BNOT, dSgn);
|
|
432
|
+
const notSignBv = this.bv(OP_BNOT, signBv);
|
|
433
|
+
const resSgnC1 = this.bv(OP_BAND, notCSgn, dSgn, signBv);
|
|
434
|
+
const resSgnC2 = this.bv(OP_BAND, cSgn, notDSgn, notSignBv);
|
|
435
|
+
const resSgnC3 = this.bv(OP_BAND, cSgn, dSgn);
|
|
436
|
+
const resSgn = this.bv(OP_BOR, resSgnC1, resSgnC2, resSgnC3);
|
|
437
|
+
const oneBit = this.num(1, 1);
|
|
438
|
+
const resSigEq = this.simpEq(signBv, oneBit);
|
|
439
|
+
const sigAbs = this.simpIte(resSigEq, nSum, sum);
|
|
440
|
+
const resSig = this.extract(sbits + 3, 0, sigAbs);
|
|
441
|
+
const resExp = this.signExtend(2, cExp);
|
|
442
|
+
return { sgn: resSgn, sig: resSig, exp: resExp };
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
mkAdd(sort: number, rm: number, x: number, y: number) {
|
|
446
|
+
const nan = this.mkNan(sort);
|
|
447
|
+
const nzero = this.mkNzero(sort);
|
|
448
|
+
const pzero = this.mkPzero(sort);
|
|
449
|
+
const xIsNan = this.mkIsNan(x);
|
|
450
|
+
const xIsZero = this.mkIsZero(x);
|
|
451
|
+
this.mkIsPos(x);
|
|
452
|
+
const xIsNeg = this.mkIsNeg(x);
|
|
453
|
+
const xIsInf = this.mkIsInf(x);
|
|
454
|
+
const yIsNan = this.mkIsNan(y);
|
|
455
|
+
const yIsZero = this.mkIsZero(y);
|
|
456
|
+
this.mkIsPos(y);
|
|
457
|
+
const yIsNeg = this.mkIsNeg(y);
|
|
458
|
+
const yIsInf = this.mkIsInf(y);
|
|
459
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
460
|
+
const c2 = this.mkIsInf(x);
|
|
461
|
+
const nx = this.mkIsNeg(x);
|
|
462
|
+
const ny = this.mkIsNeg(y);
|
|
463
|
+
const nxXorNy = this.simpXor(nx, ny);
|
|
464
|
+
const infXor = this.simpAnd(yIsInf, nxXorNy);
|
|
465
|
+
const v2 = this.mkIte(infXor, nan, x);
|
|
466
|
+
const c3 = this.mkIsInf(y);
|
|
467
|
+
const xyIsNeg = this.simpXor(xIsNeg, yIsNeg);
|
|
468
|
+
const v3And = this.simpAnd(xIsInf, xyIsNeg);
|
|
469
|
+
const v3 = this.mkIte(v3And, nan, y);
|
|
470
|
+
const c4 = this.simpAnd(xIsZero, yIsZero);
|
|
471
|
+
const signsAnd = this.simpAnd(xIsNeg, yIsNeg);
|
|
472
|
+
const signsXor = this.simpXor(xIsNeg, yIsNeg);
|
|
473
|
+
const rmIsToNeg = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
474
|
+
const rmAndXor = this.simpAnd(rmIsToNeg, signsXor);
|
|
475
|
+
const negCond = this.simpOr(signsAnd, rmAndXor);
|
|
476
|
+
const v4Zero = this.mkIte(negCond, nzero, pzero);
|
|
477
|
+
const v4And = this.simpAnd(xIsNeg, yIsNeg);
|
|
478
|
+
const v4 = this.mkIte(v4And, x, v4Zero);
|
|
479
|
+
const manager = this.manager;
|
|
480
|
+
const ebits = manager.getEbits(sort);
|
|
481
|
+
const sbits = manager.getSbits(sort);
|
|
482
|
+
const a = this.unpack(x, false);
|
|
483
|
+
const b = this.unpack(y, false);
|
|
484
|
+
const swapCond = this.bv(OP_SLEQ, a.exp, b.exp);
|
|
485
|
+
const cSgn = this.simpIte(swapCond, b.sgn, a.sgn);
|
|
486
|
+
const cSig = this.simpIte(swapCond, b.sig, a.sig);
|
|
487
|
+
const cExp = this.simpIte(swapCond, b.exp, a.exp);
|
|
488
|
+
const dSgn = this.simpIte(swapCond, a.sgn, b.sgn);
|
|
489
|
+
const dSig = this.simpIte(swapCond, a.sig, b.sig);
|
|
490
|
+
const dExp = this.simpIte(swapCond, a.exp, b.exp);
|
|
491
|
+
const res = this.addCore(sbits, ebits, cSig, cSgn, cExp, dSgn, dSig, dExp);
|
|
492
|
+
const nilSbit4 = this.num(0, sbits + 4);
|
|
493
|
+
const isZeroSig = this.simpEq(res.sig, nilSbit4);
|
|
494
|
+
const zeroCase = this.mkIte(rmIsToNeg, nzero, pzero);
|
|
495
|
+
const rounded = this.round(sort, rm, res.sgn, res.sig, res.exp);
|
|
496
|
+
const v7 = this.mkIte(isZeroSig, zeroCase, rounded);
|
|
497
|
+
const r6 = this.mkIte(yIsZero, x, v7);
|
|
498
|
+
const r5 = this.mkIte(xIsZero, y, r6);
|
|
499
|
+
const r4 = this.mkIte(c4, v4, r5);
|
|
500
|
+
const r3 = this.mkIte(c3, v3, r4);
|
|
501
|
+
const r2 = this.mkIte(c2, v2, r3);
|
|
502
|
+
return this.mkIte(c1, nan, r2);
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
mkSub(sort: number, rm: number, x: number, y: number) {
|
|
506
|
+
return this.mkAdd(sort, rm, x, this.mkNeg(y));
|
|
507
|
+
}
|
|
508
|
+
|
|
509
|
+
mkNeg(x: number) {
|
|
510
|
+
const [sgn, exp, sig] = this.splitFp(x);
|
|
511
|
+
const xIsNan = this.mkIsNan(x);
|
|
512
|
+
const nsgn = this.bv(OP_BNOT, sgn);
|
|
513
|
+
const nx = this.mkFp(nsgn, exp, sig);
|
|
514
|
+
return this.mkIte(xIsNan, x, nx);
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
mkMul(sort: number, rm: number, x: number, y: number) {
|
|
518
|
+
const nan = this.mkNan(sort);
|
|
519
|
+
const nzero = this.mkNzero(sort);
|
|
520
|
+
const pzero = this.mkPzero(sort);
|
|
521
|
+
const ninf = this.mkNinf(sort);
|
|
522
|
+
const pinf = this.mkPinf(sort);
|
|
523
|
+
const xIsNan = this.mkIsNan(x);
|
|
524
|
+
const xIsZero = this.mkIsZero(x);
|
|
525
|
+
const xIsPos = this.mkIsPos(x);
|
|
526
|
+
this.mkIsInf(x);
|
|
527
|
+
const yIsNan = this.mkIsNan(y);
|
|
528
|
+
const yIsZero = this.mkIsZero(y);
|
|
529
|
+
const yIsPos = this.mkIsPos(y);
|
|
530
|
+
this.mkIsInf(y);
|
|
531
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
532
|
+
const c2 = this.mkIsPinf(x);
|
|
533
|
+
const ySgnInf = this.mkIte(yIsPos, pinf, ninf);
|
|
534
|
+
const v2 = this.mkIte(yIsZero, nan, ySgnInf);
|
|
535
|
+
const c3 = this.mkIsPinf(y);
|
|
536
|
+
const xSgnInf = this.mkIte(xIsPos, pinf, ninf);
|
|
537
|
+
const v3 = this.mkIte(xIsZero, nan, xSgnInf);
|
|
538
|
+
const c4 = this.mkIsNinf(x);
|
|
539
|
+
const negYSgnInf = this.mkIte(yIsPos, ninf, pinf);
|
|
540
|
+
const v4 = this.mkIte(yIsZero, nan, negYSgnInf);
|
|
541
|
+
const c5 = this.mkIsNinf(y);
|
|
542
|
+
const negXSgnInf = this.mkIte(xIsPos, ninf, pinf);
|
|
543
|
+
const v5 = this.mkIte(xIsZero, nan, negXSgnInf);
|
|
544
|
+
const c6 = this.simpOr(xIsZero, yIsZero);
|
|
545
|
+
const signXor = this.simpXor(xIsPos, yIsPos);
|
|
546
|
+
const v6 = this.mkIte(signXor, nzero, pzero);
|
|
547
|
+
const sbits = this.manager.getSbits(sort);
|
|
548
|
+
const a = this.unpack(x, true);
|
|
549
|
+
const b = this.unpack(y, true);
|
|
550
|
+
const aLzExt = this.zeroExtend(2, a.lz);
|
|
551
|
+
const bLzExt = this.zeroExtend(2, b.lz);
|
|
552
|
+
const aSigExt = this.zeroExtend(sbits, a.sig);
|
|
553
|
+
const bSigExt = this.zeroExtend(sbits, b.sig);
|
|
554
|
+
const aExpSext = this.signExtend(2, a.exp);
|
|
555
|
+
const bExpSext = this.signExtend(2, b.exp);
|
|
556
|
+
const resSgn = this.bv(OP_BXOR, a.sgn, b.sgn);
|
|
557
|
+
const aExpExt = this.bv(OP_BSUB, aExpSext, aLzExt);
|
|
558
|
+
const bExpExt = this.bv(OP_BSUB, bExpSext, bLzExt);
|
|
559
|
+
const resExp = this.bv(OP_BADD, aExpExt, bExpExt);
|
|
560
|
+
const product = this.bv(OP_BMUL, aSigExt, bSigExt);
|
|
561
|
+
const hP = this.extract(2 * sbits - 1, sbits, product);
|
|
562
|
+
const lP = this.extract(sbits - 1, 0, product);
|
|
563
|
+
const rbits =
|
|
564
|
+
sbits >= 4
|
|
565
|
+
? this.concat(
|
|
566
|
+
this.extract(sbits - 1, sbits - 3, product),
|
|
567
|
+
this.bv(OP_BREDOR, this.extract(sbits - 4, 0, product)),
|
|
568
|
+
)
|
|
569
|
+
: this.concat(lP, this.num(0, 4 - sbits));
|
|
570
|
+
const resSig = this.concat(hP, rbits);
|
|
571
|
+
const v7 = this.round(sort, rm, resSgn, resSig, resExp);
|
|
572
|
+
const r6 = this.mkIte(c6, v6, v7);
|
|
573
|
+
const r5 = this.mkIte(c5, v5, r6);
|
|
574
|
+
const r4 = this.mkIte(c4, v4, r5);
|
|
575
|
+
const r3 = this.mkIte(c3, v3, r4);
|
|
576
|
+
const r2 = this.mkIte(c2, v2, r3);
|
|
577
|
+
return this.mkIte(c1, nan, r2);
|
|
578
|
+
}
|
|
579
|
+
|
|
580
|
+
mkDiv(sort: number, rm: number, x: number, y: number) {
|
|
581
|
+
const manager = this.manager;
|
|
582
|
+
const nan = this.mkNan(sort);
|
|
583
|
+
const nzero = this.mkNzero(sort);
|
|
584
|
+
const pzero = this.mkPzero(sort);
|
|
585
|
+
const ninf = this.mkNinf(sort);
|
|
586
|
+
const pinf = this.mkPinf(sort);
|
|
587
|
+
const xIsNan = this.mkIsNan(x);
|
|
588
|
+
const xIsZero = this.mkIsZero(x);
|
|
589
|
+
const xIsPos = this.mkIsPos(x);
|
|
590
|
+
const xIsInf = this.mkIsInf(x);
|
|
591
|
+
const yIsNan = this.mkIsNan(y);
|
|
592
|
+
const yIsZero = this.mkIsZero(y);
|
|
593
|
+
const yIsPos = this.mkIsPos(y);
|
|
594
|
+
const yIsInf = this.mkIsInf(y);
|
|
595
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
596
|
+
const c2 = this.mkIsPinf(x);
|
|
597
|
+
const ySgnInf = this.mkIte(yIsPos, pinf, ninf);
|
|
598
|
+
const v2 = this.mkIte(yIsInf, nan, ySgnInf);
|
|
599
|
+
const c3 = this.mkIsPinf(y);
|
|
600
|
+
const signsXor = this.simpXor(xIsPos, yIsPos);
|
|
601
|
+
const xyZero = this.mkIte(signsXor, nzero, pzero);
|
|
602
|
+
const v3 = this.mkIte(xIsInf, nan, xyZero);
|
|
603
|
+
const c4 = this.mkIsNinf(x);
|
|
604
|
+
const negYSgnInf = this.mkIte(yIsPos, ninf, pinf);
|
|
605
|
+
const v4 = this.mkIte(yIsInf, nan, negYSgnInf);
|
|
606
|
+
const c5 = this.mkIsNinf(y);
|
|
607
|
+
const v5 = this.mkIte(xIsInf, nan, xyZero);
|
|
608
|
+
const sgnInf = this.mkIte(signsXor, ninf, pinf);
|
|
609
|
+
const v6 = this.mkIte(xIsZero, nan, sgnInf);
|
|
610
|
+
const v7 = this.mkIte(signsXor, nzero, pzero);
|
|
611
|
+
const ebits = manager.getEbits(sort);
|
|
612
|
+
const sbits = manager.getSbits(sort);
|
|
613
|
+
const lzModulus = 1n << BigInt(ebits);
|
|
614
|
+
const needsWideLz = lzModulus < BigInt(sbits);
|
|
615
|
+
const expBits = needsWideLz ? getBigLog2(lzModulus + BigInt(sbits) - 4n) + 2 : ebits + 2;
|
|
616
|
+
const lzBits = needsWideLz ? getLog2(sbits - 1) + 1 : ebits;
|
|
617
|
+
const a = this.unpack(x, !needsWideLz);
|
|
618
|
+
const b = this.unpack(y, !needsWideLz);
|
|
619
|
+
if (needsWideLz) {
|
|
620
|
+
const zeroSig = this.num(0, sbits);
|
|
621
|
+
const aSigIsZero = this.simpEq(zeroSig, a.sig);
|
|
622
|
+
const bSigIsZero = this.simpEq(zeroSig, b.sig);
|
|
623
|
+
const zeroLz = this.num(0, lzBits);
|
|
624
|
+
const aLzRaw = this.mkLeadingZeros(a.sig, lzBits);
|
|
625
|
+
const bLzRaw = this.mkLeadingZeros(b.sig, lzBits);
|
|
626
|
+
a.lz = this.simpIte(aSigIsZero, zeroLz, aLzRaw);
|
|
627
|
+
b.lz = this.simpIte(bSigIsZero, zeroLz, bLzRaw);
|
|
628
|
+
const aShift = this.zeroExtend(sbits - lzBits, a.lz);
|
|
629
|
+
const bShift = this.zeroExtend(sbits - lzBits, b.lz);
|
|
630
|
+
a.sig = this.bv(OP_BSHL, a.sig, aShift);
|
|
631
|
+
b.sig = this.bv(OP_BSHL, b.sig, bShift);
|
|
632
|
+
}
|
|
633
|
+
const extraBits = sbits + 2;
|
|
634
|
+
const aSigExt = this.concat(a.sig, this.num(0, sbits + extraBits));
|
|
635
|
+
const bSigExt = this.zeroExtend(sbits + extraBits, b.sig);
|
|
636
|
+
const aExpSext = this.signExtend(expBits - ebits, a.exp);
|
|
637
|
+
const bExpSext = this.signExtend(expBits - ebits, b.exp);
|
|
638
|
+
const resSgn = this.bv(OP_BXOR, a.sgn, b.sgn);
|
|
639
|
+
const aLzExt = this.zeroExtend(expBits - lzBits, a.lz);
|
|
640
|
+
const bLzExt = this.zeroExtend(expBits - lzBits, b.lz);
|
|
641
|
+
const aExpExt = this.bv(OP_BSUB, aExpSext, aLzExt);
|
|
642
|
+
const bExpExt = this.bv(OP_BSUB, bExpSext, bLzExt);
|
|
643
|
+
const quotientExp = this.bv(OP_BSUB, aExpExt, bExpExt);
|
|
644
|
+
const quotient = this.bv(OP_BUDIV_I, aSigExt, bSigExt);
|
|
645
|
+
const sticky = this.bv(OP_BREDOR, this.extract(extraBits - 2, 0, quotient));
|
|
646
|
+
const quotientSig = this.concat(
|
|
647
|
+
this.extract(extraBits + sbits + 1, extraBits - 1, quotient),
|
|
648
|
+
sticky,
|
|
649
|
+
);
|
|
650
|
+
const tooLarge =
|
|
651
|
+
sbits === 2
|
|
652
|
+
? manager.falseExpr
|
|
653
|
+
: manager.mkEq(
|
|
654
|
+
this.bv(
|
|
655
|
+
OP_BREDOR,
|
|
656
|
+
this.extract(sbits + sbits + extraBits - 1, extraBits + sbits + 2, quotient),
|
|
657
|
+
),
|
|
658
|
+
this.num(1, 1),
|
|
659
|
+
);
|
|
660
|
+
const v8 = this.mkIte(signsXor, ninf, pinf);
|
|
661
|
+
const resSigLz = this.mkLeadingZeros(quotientSig, sbits + 4);
|
|
662
|
+
const resSigShiftAmount = this.bv(OP_BSUB, resSigLz, this.num(1, sbits + 4));
|
|
663
|
+
const shiftCond = this.bv(OP_ULEQ, resSigLz, this.num(1, sbits + 4));
|
|
664
|
+
const resSigShifted = this.bv(OP_BSHL, quotientSig, resSigShiftAmount);
|
|
665
|
+
const expShiftAmount =
|
|
666
|
+
expBits <= sbits + 4
|
|
667
|
+
? this.extract(expBits - 1, 0, resSigShiftAmount)
|
|
668
|
+
: this.zeroExtend(expBits - (sbits + 4), resSigShiftAmount);
|
|
669
|
+
const resExpShifted = this.bv(OP_BSUB, quotientExp, expShiftAmount);
|
|
670
|
+
const resSig = this.simpIte(shiftCond, quotientSig, resSigShifted);
|
|
671
|
+
const resExp = this.simpIte(shiftCond, quotientExp, resExpShifted);
|
|
672
|
+
let v9: number;
|
|
673
|
+
if (expBits > ebits + 2) {
|
|
674
|
+
const roundExpBits = ebits + 2;
|
|
675
|
+
const sigSize = sbits + 4;
|
|
676
|
+
const roundMinExp = this.num(-(1n << BigInt(ebits + 1)), roundExpBits);
|
|
677
|
+
const roundMaxExp = this.num(getPowerOfTwoMinusOne(ebits + 1), roundExpBits);
|
|
678
|
+
const roundMinExpExt = this.signExtend(expBits - roundExpBits, roundMinExp);
|
|
679
|
+
const roundMaxExpExt = this.signExtend(expBits - roundExpBits, roundMaxExp);
|
|
680
|
+
const expBelowRoundRange = this.bv(OP_SLT, resExp, roundMinExpExt);
|
|
681
|
+
const expAboveRoundRange = this.bv(OP_SLT, roundMaxExpExt, resExp);
|
|
682
|
+
const narrowedExp = this.extract(roundExpBits - 1, 0, resExp);
|
|
683
|
+
const cappedExp = this.simpIte(expAboveRoundRange, roundMaxExp, narrowedExp);
|
|
684
|
+
const roundExp = this.simpIte(expBelowRoundRange, roundMinExp, cappedExp);
|
|
685
|
+
const minExp = this.mkMinExp(ebits);
|
|
686
|
+
const minExpExt = this.signExtend(expBits - ebits, minExp);
|
|
687
|
+
const shift = this.bv(OP_BSUB, minExpExt, resExp);
|
|
688
|
+
const underflowShift = this.bv(OP_BSUB, shift, this.num(1, expBits));
|
|
689
|
+
const underflowShiftSized = this.zeroExtend(2 * sigSize - expBits, underflowShift);
|
|
690
|
+
const sigExt = this.concat(resSig, this.num(0, sigSize));
|
|
691
|
+
const shiftedSig = this.bv(OP_BLSHR, sigExt, underflowShiftSized);
|
|
692
|
+
const sigExtractLowBit = 2 * sigSize - (sbits + 2);
|
|
693
|
+
const discarded = this.bv(OP_BREDOR, this.extract(sigExtractLowBit - 1, 0, shiftedSig));
|
|
694
|
+
const underflowSigRaw = this.extract(2 * sigSize - 1, sigExtractLowBit, shiftedSig);
|
|
695
|
+
const stickyExt = this.zeroExtend(sbits + 1, discarded);
|
|
696
|
+
const underflowSig = this.bv(OP_BOR, underflowSigRaw, stickyExt);
|
|
697
|
+
const underflowSticky = this.extract(0, 0, underflowSig);
|
|
698
|
+
const underflowRound = this.extract(1, 1, underflowSig);
|
|
699
|
+
const underflowLast = this.extract(2, 2, underflowSig);
|
|
700
|
+
const underflowRetained = this.extract(sbits + 1, 2, underflowSig);
|
|
701
|
+
const underflowInc = this.mkRoundingDecision(
|
|
702
|
+
rm,
|
|
703
|
+
resSgn,
|
|
704
|
+
underflowLast,
|
|
705
|
+
underflowRound,
|
|
706
|
+
underflowSticky,
|
|
707
|
+
);
|
|
708
|
+
const underflowRoundedSig = this.bv(
|
|
709
|
+
OP_BADD,
|
|
710
|
+
underflowRetained,
|
|
711
|
+
this.zeroExtend(sbits - 1, underflowInc),
|
|
712
|
+
);
|
|
713
|
+
const underflowExp = this.num(0, ebits);
|
|
714
|
+
const underflowFrac = this.extract(sbits - 2, 0, underflowRoundedSig);
|
|
715
|
+
const underflowResult = this.mkFp(resSgn, underflowExp, underflowFrac);
|
|
716
|
+
const rounded = this.round(sort, rm, resSgn, resSig, roundExp);
|
|
717
|
+
v9 = this.mkIte(expBelowRoundRange, underflowResult, rounded);
|
|
718
|
+
} else v9 = this.round(sort, rm, resSgn, resSig, resExp);
|
|
719
|
+
const r8 = this.mkIte(tooLarge, v8, v9);
|
|
720
|
+
const r7 = this.mkIte(xIsZero, v7, r8);
|
|
721
|
+
const r6 = this.mkIte(yIsZero, v6, r7);
|
|
722
|
+
const r5 = this.mkIte(c5, v5, r6);
|
|
723
|
+
const r4 = this.mkIte(c4, v4, r5);
|
|
724
|
+
const r3 = this.mkIte(c3, v3, r4);
|
|
725
|
+
const r2 = this.mkIte(c2, v2, r3);
|
|
726
|
+
return this.mkIte(c1, nan, r2);
|
|
727
|
+
}
|
|
728
|
+
|
|
729
|
+
mkRem(sort: number, x: number, y: number) {
|
|
730
|
+
const manager = this.manager;
|
|
731
|
+
const nan = this.mkNan(sort);
|
|
732
|
+
const nzero = this.mkNzero(sort);
|
|
733
|
+
const pzero = this.mkPzero(sort);
|
|
734
|
+
this.mkNinf(sort);
|
|
735
|
+
this.mkPinf(sort);
|
|
736
|
+
const xIsNan = this.mkIsNan(x);
|
|
737
|
+
const xIsZero = this.mkIsZero(x);
|
|
738
|
+
const xIsPos = this.mkIsPos(x);
|
|
739
|
+
this.mkIsNeg(x);
|
|
740
|
+
const xIsInf = this.mkIsInf(x);
|
|
741
|
+
const yIsNan = this.mkIsNan(y);
|
|
742
|
+
const yIsZero = this.mkIsZero(y);
|
|
743
|
+
this.mkIsPos(y);
|
|
744
|
+
this.mkIsNeg(y);
|
|
745
|
+
const yIsInf = this.mkIsInf(y);
|
|
746
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
747
|
+
const ebits = manager.getEbits(sort);
|
|
748
|
+
const sbits = manager.getSbits(sort);
|
|
749
|
+
const [, xExp] = this.splitFp(x);
|
|
750
|
+
const [, yExp] = this.splitFp(y);
|
|
751
|
+
const oneEbits = this.num(1, ebits);
|
|
752
|
+
const yExpM1 = this.bv(OP_BSUB, yExp, oneEbits);
|
|
753
|
+
const xeLtYem1 = this.bvUlt(xExp, yExpM1);
|
|
754
|
+
const yeNeqZero = manager.mkNot(manager.mkEq(yExp, this.num(0, ebits)));
|
|
755
|
+
const c6 = this.mkAnd(yeNeqZero, xeLtYem1);
|
|
756
|
+
const a = this.unpack(x, true);
|
|
757
|
+
const b = this.unpack(y, true);
|
|
758
|
+
const maxExpDiff = (1n << BigInt(ebits)) - 3n;
|
|
759
|
+
const sigExtAmount = maxExpDiff + BigInt(sbits) - 1n;
|
|
760
|
+
if (sigExtAmount > 2147483647n) throw new SmtUnsupportedError("huge exponents in fp.rem");
|
|
761
|
+
const aExpExt = this.signExtend(2, a.exp);
|
|
762
|
+
const bExpExt = this.signExtend(2, b.exp);
|
|
763
|
+
const aLzExt = this.zeroExtend(2, a.lz);
|
|
764
|
+
const bLzExt = this.zeroExtend(2, b.lz);
|
|
765
|
+
const aExpAdj = this.bv(OP_BSUB, aExpExt, aLzExt);
|
|
766
|
+
const bExpAdj = this.bv(OP_BSUB, bExpExt, bLzExt);
|
|
767
|
+
const expDiff = this.bv(OP_BSUB, aExpAdj, bExpAdj);
|
|
768
|
+
const negExpDiff = this.bv(OP_BNEG, expDiff);
|
|
769
|
+
const expDiffIsNeg = this.bv(OP_SLEQ, expDiff, this.num(0, ebits + 2));
|
|
770
|
+
manager.mkEq(expDiff, this.num(0, ebits + 2));
|
|
771
|
+
this.bv(OP_SLEQ, this.num(0, this.getBvSize(expDiff)), expDiff);
|
|
772
|
+
const extension = Number(sigExtAmount);
|
|
773
|
+
const aSigExtL = extension === 0 ? a.sig : this.zeroExtend(extension, a.sig);
|
|
774
|
+
const bSigExtL = extension === 0 ? b.sig : this.zeroExtend(extension, b.sig);
|
|
775
|
+
const aSigExt = this.concat(aSigExtL, this.num(0, 3));
|
|
776
|
+
const bSigExt = this.concat(bSigExtL, this.num(0, 3));
|
|
777
|
+
const maxExpDiffAdj = extension + sbits - ebits + 1;
|
|
778
|
+
const lshift = maxExpDiffAdj === 0 ? expDiff : this.zeroExtend(maxExpDiffAdj, expDiff);
|
|
779
|
+
const rshift = maxExpDiffAdj === 0 ? negExpDiff : this.zeroExtend(maxExpDiffAdj, negExpDiff);
|
|
780
|
+
const shiftedRight = this.bv(OP_BASHR, aSigExt, rshift);
|
|
781
|
+
const shiftedLeft = this.bv(OP_BSHL, aSigExt, lshift);
|
|
782
|
+
const shifted = this.mkRawIte(expDiffIsNeg, shiftedRight, shiftedLeft);
|
|
783
|
+
const hugeRem = this.bv(OP_BUREM, shifted, bSigExt);
|
|
784
|
+
const hugeDiv = this.bv(OP_BUDIV_I, shifted, bSigExt);
|
|
785
|
+
const hugeDivIsEven = manager.mkEq(this.extract(0, 0, hugeDiv), this.num(0, 1));
|
|
786
|
+
const rnddSgn = a.sgn;
|
|
787
|
+
const rnddExp = this.bv(OP_BSUB, bExpExt, bLzExt);
|
|
788
|
+
const rnddSig = this.extract(sbits + 3, 0, hugeRem);
|
|
789
|
+
const rneBv = this.num(BV_RM_TIES_TO_EVEN, 3);
|
|
790
|
+
const rnddSigLz = this.mkLeadingZeros(rnddSig, ebits + 2);
|
|
791
|
+
const rnddExpEqYExp = manager.mkEq(rnddSigLz, this.num(1, ebits + 2));
|
|
792
|
+
const rnddExpEqYExpM1 = manager.mkEq(rnddSigLz, this.num(2, ebits + 2));
|
|
793
|
+
const ySigExt = this.concat(this.zeroExtend(2, b.sig), this.num(0, 2));
|
|
794
|
+
const ySigLeRnddSig = this.bv(OP_SLEQ, ySigExt, rnddSig);
|
|
795
|
+
const ySigEqRnddSig = manager.mkEq(ySigExt, rnddSig);
|
|
796
|
+
const adjCnd1 = this.mkAnd(rnddExpEqYExp, ySigLeRnddSig);
|
|
797
|
+
const adjCnd2 = this.mkAnd(rnddExpEqYExpM1, ySigLeRnddSig, manager.mkNot(ySigEqRnddSig));
|
|
798
|
+
const adjCnd3 = this.mkAnd(rnddExpEqYExpM1, ySigEqRnddSig, manager.mkNot(hugeDivIsEven));
|
|
799
|
+
const adjCnd = this.mkOr(adjCnd1, adjCnd2, adjCnd3);
|
|
800
|
+
const rndd = this.round(sort, rneBv, rnddSgn, rnddSig, rnddExp);
|
|
801
|
+
const roundedSubY = this.mkSub(sort, rneBv, rndd, y);
|
|
802
|
+
const roundedAddY = this.mkAdd(sort, rneBv, rndd, y);
|
|
803
|
+
const addCnd = manager.mkNot(manager.mkEq(rnddSgn, b.sgn));
|
|
804
|
+
const adjusted = this.mkIte(addCnd, roundedAddY, roundedSubY);
|
|
805
|
+
const v7 = this.mkIte(adjCnd, adjusted, rndd);
|
|
806
|
+
const r6 = this.mkIte(c6, x, v7);
|
|
807
|
+
const r5 = this.mkIte(xIsZero, pzero, r6);
|
|
808
|
+
const r4 = this.mkIte(yIsZero, nan, r5);
|
|
809
|
+
const r3 = this.mkIte(yIsInf, x, r4);
|
|
810
|
+
const r2 = this.mkIte(xIsInf, nan, r3);
|
|
811
|
+
const r1 = this.mkIte(c1, nan, r2);
|
|
812
|
+
const resultIsZero = this.mkIsZero(r1);
|
|
813
|
+
const zeros = this.mkIte(xIsPos, pzero, nzero);
|
|
814
|
+
return this.mkIte(resultIsZero, zeros, r1);
|
|
815
|
+
}
|
|
816
|
+
|
|
817
|
+
mkAbs(x: number) {
|
|
818
|
+
const [, exp, sig] = this.splitFp(x);
|
|
819
|
+
return this.mkFp(this.num(0, 1), exp, sig);
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
mkMinMax(decl: number, args: number[], isMax: boolean) {
|
|
823
|
+
const manager = this.manager;
|
|
824
|
+
const x = args[0];
|
|
825
|
+
const y = args[1];
|
|
826
|
+
const [xSgn] = this.splitFp(x);
|
|
827
|
+
const [ySgn] = this.splitFp(y);
|
|
828
|
+
if (!isMax) {
|
|
829
|
+
this.num(0, 1);
|
|
830
|
+
this.num(1, 1);
|
|
831
|
+
}
|
|
832
|
+
const xIsNan = this.mkIsNan(x);
|
|
833
|
+
const yIsNan = this.mkIsNan(y);
|
|
834
|
+
const xIsZero = this.mkIsZero(x);
|
|
835
|
+
const yIsZero = this.mkIsZero(y);
|
|
836
|
+
const xyAreZero = this.mkAnd(xIsZero, yIsZero);
|
|
837
|
+
this.mkIsPos(x);
|
|
838
|
+
this.mkIsPos(y);
|
|
839
|
+
this.mkIsNeg(x);
|
|
840
|
+
this.mkIsNeg(y);
|
|
841
|
+
const pnOrNpZeros = this.mkAnd(xyAreZero, manager.mkNot(manager.mkEq(xSgn, ySgn)));
|
|
842
|
+
const unspecified = this.mkMinMaxUnspecified(decl, x, y);
|
|
843
|
+
const compared = isMax ? this.mkFloatGt(x, y) : this.mkFloatLt(x, y);
|
|
844
|
+
const ordered = this.mkIte(compared, x, y);
|
|
845
|
+
const withZeros = this.mkIte(xyAreZero, y, ordered);
|
|
846
|
+
const withUnspecified = this.mkIte(pnOrNpZeros, unspecified, withZeros);
|
|
847
|
+
const withYNan = this.mkIte(yIsNan, x, withUnspecified);
|
|
848
|
+
return this.mkIte(xIsNan, y, withYNan);
|
|
849
|
+
}
|
|
850
|
+
|
|
851
|
+
mkMinMaxI(op: number, args: number[]) {
|
|
852
|
+
const manager = this.manager;
|
|
853
|
+
const sort = manager.sorts[args[0]];
|
|
854
|
+
const decl = manager.mkFpaDecl(
|
|
855
|
+
op,
|
|
856
|
+
op === OP_FPA_MIN ? "fp.min" : "fp.max",
|
|
857
|
+
[],
|
|
858
|
+
[sort, sort],
|
|
859
|
+
sort,
|
|
860
|
+
);
|
|
861
|
+
return this.mkMinMax(decl, args, op === OP_FPA_MAX);
|
|
862
|
+
}
|
|
863
|
+
|
|
864
|
+
private mkMinMaxUnspecified(decl: number, x: number, y: number) {
|
|
865
|
+
const manager = this.manager;
|
|
866
|
+
const range = manager.funcDecls[decl].range;
|
|
867
|
+
const ebits = manager.getEbits(range);
|
|
868
|
+
const sbits = manager.getSbits(range);
|
|
869
|
+
let decls = this.minMaxUfs.get(decl);
|
|
870
|
+
if (decls === undefined) {
|
|
871
|
+
const bitSort = manager.mkBvSort(1);
|
|
872
|
+
decls = [manager.mkFreshConst(null, bitSort), manager.mkFreshConst(null, bitSort)];
|
|
873
|
+
this.minMaxUfs.set(decl, decls);
|
|
874
|
+
manager.incDeclRef(decl);
|
|
875
|
+
manager.incRef(decls[0]);
|
|
876
|
+
manager.incRef(decls[1]);
|
|
877
|
+
}
|
|
878
|
+
const pn = this.mkFp(decls[0], this.num(0, ebits), this.num(0, sbits - 1));
|
|
879
|
+
const np = this.mkFp(decls[1], this.num(0, ebits), this.num(0, sbits - 1));
|
|
880
|
+
const xIsPzero = this.mkIsPzero(x);
|
|
881
|
+
const yIsNzero = this.mkIsNzero(y);
|
|
882
|
+
const xyZero = this.simpAnd(xIsPzero, yIsNzero);
|
|
883
|
+
return this.mkIte(xyZero, pn, np);
|
|
884
|
+
}
|
|
885
|
+
|
|
886
|
+
mkFma(sort: number, rm: number, x: number, y: number, z: number) {
|
|
887
|
+
const manager = this.manager;
|
|
888
|
+
const nan = this.mkNan(sort);
|
|
889
|
+
const nzero = this.mkNzero(sort);
|
|
890
|
+
const pzero = this.mkPzero(sort);
|
|
891
|
+
const ninf = this.mkNinf(sort);
|
|
892
|
+
const pinf = this.mkPinf(sort);
|
|
893
|
+
const xIsNan = this.mkIsNan(x);
|
|
894
|
+
const xIsZero = this.mkIsZero(x);
|
|
895
|
+
const xIsPos = this.mkIsPos(x);
|
|
896
|
+
const xIsNeg = this.mkIsNeg(x);
|
|
897
|
+
this.mkIsInf(x);
|
|
898
|
+
const yIsNan = this.mkIsNan(y);
|
|
899
|
+
const yIsZero = this.mkIsZero(y);
|
|
900
|
+
const yIsPos = this.mkIsPos(y);
|
|
901
|
+
const yIsNeg = this.mkIsNeg(y);
|
|
902
|
+
this.mkIsInf(y);
|
|
903
|
+
const zIsNan = this.mkIsNan(z);
|
|
904
|
+
const zIsZero = this.mkIsZero(z);
|
|
905
|
+
this.mkIsPos(z);
|
|
906
|
+
const zIsNeg = this.mkIsNeg(z);
|
|
907
|
+
const zIsInf = this.mkIsInf(z);
|
|
908
|
+
const rmIsToNeg = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
909
|
+
const infXor = this.simpXor(this.simpXor(xIsNeg, yIsNeg), zIsNeg);
|
|
910
|
+
const infCond = this.simpAnd(zIsInf, infXor);
|
|
911
|
+
const c1 = this.simpOr(xIsNan, yIsNan, zIsNan);
|
|
912
|
+
const c2 = this.mkIsPinf(x);
|
|
913
|
+
const ySgnInf = this.mkIte(yIsPos, pinf, ninf);
|
|
914
|
+
const v2 = this.mkIte(this.simpOr(yIsZero, infCond), nan, ySgnInf);
|
|
915
|
+
const c3 = this.mkIsPinf(y);
|
|
916
|
+
const xSgnInf = this.mkIte(xIsPos, pinf, ninf);
|
|
917
|
+
const v3 = this.mkIte(this.simpOr(xIsZero, infCond), nan, xSgnInf);
|
|
918
|
+
const c4 = this.mkIsNinf(x);
|
|
919
|
+
const negYSgnInf = this.mkIte(yIsPos, ninf, pinf);
|
|
920
|
+
const v4 = this.mkIte(this.simpOr(yIsZero, infCond), nan, negYSgnInf);
|
|
921
|
+
const c5 = this.mkIsNinf(y);
|
|
922
|
+
const negXSgnInf = this.mkIte(xIsPos, ninf, pinf);
|
|
923
|
+
const v5 = this.mkIte(this.simpOr(xIsZero, infCond), nan, negXSgnInf);
|
|
924
|
+
const c6 = this.mkIsInf(z);
|
|
925
|
+
const c7 = this.simpOr(xIsZero, yIsZero);
|
|
926
|
+
const xySgn = this.simpXor(xIsNeg, yIsNeg);
|
|
927
|
+
const xyzSgn = this.simpXor(xySgn, zIsNeg);
|
|
928
|
+
const c71 = this.simpAnd(zIsZero, xyzSgn);
|
|
929
|
+
manager.mkNot(rmIsToNeg);
|
|
930
|
+
const zeroCond = this.simpIte(rmIsToNeg, nzero, pzero);
|
|
931
|
+
const v7 = this.mkIte(c71, zeroCond, z);
|
|
932
|
+
const oneBit = this.num(1, 1);
|
|
933
|
+
const zeroBit = this.num(0, 1);
|
|
934
|
+
const ebits = manager.getEbits(sort);
|
|
935
|
+
const sbits = manager.getSbits(sort);
|
|
936
|
+
const a = this.unpack(x, true);
|
|
937
|
+
const b = this.unpack(y, true);
|
|
938
|
+
const c = this.unpack(z, true);
|
|
939
|
+
const aLzExt = this.zeroExtend(2, a.lz);
|
|
940
|
+
const bLzExt = this.zeroExtend(2, b.lz);
|
|
941
|
+
const cLzExt = this.zeroExtend(2, c.lz);
|
|
942
|
+
const aSigExt = this.zeroExtend(sbits, a.sig);
|
|
943
|
+
const bSigExt = this.zeroExtend(sbits, b.sig);
|
|
944
|
+
const aExpSext = this.signExtend(2, a.exp);
|
|
945
|
+
const bExpSext = this.signExtend(2, b.exp);
|
|
946
|
+
const cExpSext = this.signExtend(2, c.exp);
|
|
947
|
+
const mulSgn = this.bv(OP_BXOR, a.sgn, b.sgn);
|
|
948
|
+
const aExpExt = this.bv(OP_BSUB, aExpSext, aLzExt);
|
|
949
|
+
const bExpExt = this.bv(OP_BSUB, bExpSext, bLzExt);
|
|
950
|
+
const mulExp = this.bv(OP_BADD, aExpExt, bExpExt);
|
|
951
|
+
const product = this.bv(OP_BMUL, aSigExt, bSigExt);
|
|
952
|
+
const cSigExt = this.zeroExtend(1, this.concat(c.sig, this.num(0, sbits + 2)));
|
|
953
|
+
const cExpExt = this.bv(OP_BSUB, cExpSext, cLzExt);
|
|
954
|
+
const mulSig = this.concat(product, this.num(0, 3));
|
|
955
|
+
const swapCond = this.bv(OP_SLEQ, mulExp, cExpExt);
|
|
956
|
+
const eSgn = this.simpIte(swapCond, c.sgn, mulSgn);
|
|
957
|
+
const eSigRaw = this.simpIte(swapCond, cSigExt, mulSig);
|
|
958
|
+
const eExp = this.simpIte(swapCond, cExpExt, mulExp);
|
|
959
|
+
const fSgn = this.simpIte(swapCond, mulSgn, c.sgn);
|
|
960
|
+
const fSig = this.simpIte(swapCond, mulSig, cSigExt);
|
|
961
|
+
const fExp = this.simpIte(swapCond, mulExp, cExpExt);
|
|
962
|
+
const delta = this.bv(OP_BSUB, eExp, fExp);
|
|
963
|
+
const cap = this.num(2 * sbits + 3, ebits + 2);
|
|
964
|
+
const capLeDelta = this.bv(OP_ULEQ, cap, delta);
|
|
965
|
+
const expDelta = this.simpIte(capLeDelta, cap, delta);
|
|
966
|
+
const fSigExt = this.concat(fSig, this.num(0, sbits));
|
|
967
|
+
const expDeltaExt = this.zeroExtend(3 * sbits + 3 - (ebits + 2), expDelta);
|
|
968
|
+
const shiftedBig = this.bv(OP_BLSHR, fSigExt, expDeltaExt);
|
|
969
|
+
const shiftedFSigRaw = this.extract(3 * sbits + 2, sbits, shiftedBig);
|
|
970
|
+
const alignmentStickyRaw = this.extract(sbits - 1, 0, shiftedBig);
|
|
971
|
+
const alignmentSticky = this.bv(OP_BREDOR, alignmentStickyRaw);
|
|
972
|
+
const eSig = this.zeroExtend(2, eSigRaw);
|
|
973
|
+
const shiftedFSig = this.zeroExtend(2, shiftedFSigRaw);
|
|
974
|
+
const eqSgn = this.simpEq(eSgn, fSgn);
|
|
975
|
+
const stickyWide = this.zeroExtend(2 * sbits + 4, alignmentSticky);
|
|
976
|
+
const ePlusFRaw = this.bv(OP_BADD, eSig, shiftedFSig);
|
|
977
|
+
const plusStickyCond = manager.mkEq(this.extract(0, 0, ePlusFRaw), zeroBit);
|
|
978
|
+
const plusWithSticky = this.bv(OP_BADD, ePlusFRaw, stickyWide);
|
|
979
|
+
const ePlusF = this.mkRawIte(plusStickyCond, plusWithSticky, ePlusFRaw);
|
|
980
|
+
const eMinusFRaw = this.bv(OP_BSUB, eSig, shiftedFSig);
|
|
981
|
+
const minusStickyCond = manager.mkEq(this.extract(0, 0, eMinusFRaw), zeroBit);
|
|
982
|
+
const minusWithSticky = this.bv(OP_BSUB, eMinusFRaw, stickyWide);
|
|
983
|
+
const eMinusF = this.mkRawIte(minusStickyCond, minusWithSticky, eMinusFRaw);
|
|
984
|
+
const sum = this.simpIte(eqSgn, ePlusF, eMinusF);
|
|
985
|
+
const signBv = this.extract(2 * sbits + 4, 2 * sbits + 4, sum);
|
|
986
|
+
const nSum = this.bv(OP_BNEG, sum);
|
|
987
|
+
const resSigEq = this.simpEq(signBv, oneBit);
|
|
988
|
+
const sigAbsRaw = this.simpIte(resSigEq, nSum, sum);
|
|
989
|
+
const notESgn = this.bv(OP_BNOT, eSgn);
|
|
990
|
+
const notFSgn = this.bv(OP_BNOT, fSgn);
|
|
991
|
+
const notSignBv = this.bv(OP_BNOT, signBv);
|
|
992
|
+
const resSgnC1 = this.bv(OP_BAND, notESgn, fSgn, signBv);
|
|
993
|
+
const resSgnC2 = this.bv(OP_BAND, eSgn, notFSgn, notSignBv);
|
|
994
|
+
const resSgnC3 = this.bv(OP_BAND, eSgn, fSgn);
|
|
995
|
+
const resSgn = this.bv(OP_BOR, resSgnC1, resSgnC2, resSgnC3);
|
|
996
|
+
const isSigNeg = manager.mkEq(oneBit, this.extract(2 * sbits + 4, 2 * sbits + 4, sigAbsRaw));
|
|
997
|
+
const sigAbsSigned = this.mkRawIte(isSigNeg, this.bv(OP_BNEG, sigAbsRaw), sigAbsRaw);
|
|
998
|
+
const extra = this.extract(2 * sbits + 4, 2 * sbits + 3, sigAbsSigned);
|
|
999
|
+
const extraIsZero = manager.mkEq(extra, this.num(0, 2));
|
|
1000
|
+
const expUnnormalized = this.mkRawIte(
|
|
1001
|
+
extraIsZero,
|
|
1002
|
+
eExp,
|
|
1003
|
+
this.bv(OP_BADD, eExp, this.num(1, ebits + 2)),
|
|
1004
|
+
);
|
|
1005
|
+
const zeroE2 = this.num(0, ebits + 2);
|
|
1006
|
+
const minExp = this.signExtend(2, this.mkMinExp(ebits));
|
|
1007
|
+
const sigLzRaw = this.mkLeadingZeros(sigAbsSigned, ebits + 2);
|
|
1008
|
+
const sigLz = this.bv(OP_BSUB, sigLzRaw, this.num(2, ebits + 2));
|
|
1009
|
+
const maxExpDelta = this.bv(OP_BSUB, expUnnormalized, minExp);
|
|
1010
|
+
const sigLzCapped = this.mkRawIte(this.bv(OP_SLEQ, sigLz, maxExpDelta), sigLz, maxExpDelta);
|
|
1011
|
+
const renormDelta = this.mkRawIte(this.bv(OP_SLEQ, zeroE2, sigLzCapped), sigLzCapped, zeroE2);
|
|
1012
|
+
const resExp = this.bv(OP_BSUB, expUnnormalized, renormDelta);
|
|
1013
|
+
const sigAbsShifted = this.bv(
|
|
1014
|
+
OP_BSHL,
|
|
1015
|
+
sigAbsSigned,
|
|
1016
|
+
this.zeroExtend(2 * sbits + 3 - ebits, renormDelta),
|
|
1017
|
+
);
|
|
1018
|
+
const tooShort = sbits < 5 ? 6 - sbits + 1 : 0;
|
|
1019
|
+
const sigAbs = sbits < 5 ? this.concat(sigAbsShifted, this.num(0, tooShort)) : sigAbsShifted;
|
|
1020
|
+
const stickyH1 = this.extract(sbits + tooShort - 2, 0, sigAbs);
|
|
1021
|
+
const sigAbsH1 = this.extract(2 * sbits + tooShort + 4, sbits - 1 + tooShort, sigAbs);
|
|
1022
|
+
const stickyH1Red = this.zeroExtend(sbits + 5, this.bv(OP_BREDOR, stickyH1));
|
|
1023
|
+
const sigAbsH1F = this.bv(OP_BOR, sigAbsH1, stickyH1Red);
|
|
1024
|
+
const resSig1 = this.extract(sbits + 3, 0, sigAbsH1F);
|
|
1025
|
+
const stickyH2 = this.extract(sbits + tooShort - 1, 0, sigAbs);
|
|
1026
|
+
const sigAbsH2 = this.extract(2 * sbits + tooShort + 4, sbits + tooShort, sigAbs);
|
|
1027
|
+
const stickyH2Red = this.zeroExtend(sbits + 4, this.bv(OP_BREDOR, stickyH2));
|
|
1028
|
+
const sigAbsH2F = this.zeroExtend(1, this.bv(OP_BOR, sigAbsH2, stickyH2Red));
|
|
1029
|
+
const resSig2 = this.extract(sbits + 3, 0, sigAbsH2F);
|
|
1030
|
+
const resSig = this.mkRawIte(extraIsZero, resSig1, resSig2);
|
|
1031
|
+
const nilSbits4 = this.num(0, sbits + 4);
|
|
1032
|
+
const isZeroSig = this.simpEq(resSig, nilSbits4);
|
|
1033
|
+
const zeroCase = this.mkIte(rmIsToNeg, nzero, pzero);
|
|
1034
|
+
const rounded = this.round(sort, rm, resSgn, resSig, resExp);
|
|
1035
|
+
const v8 = this.mkIte(isZeroSig, zeroCase, rounded);
|
|
1036
|
+
const r7 = this.mkIte(c7, v7, v8);
|
|
1037
|
+
const r6 = this.mkIte(c6, z, r7);
|
|
1038
|
+
const r5 = this.mkIte(c5, v5, r6);
|
|
1039
|
+
const r4 = this.mkIte(c4, v4, r5);
|
|
1040
|
+
const r3 = this.mkIte(c3, v3, r4);
|
|
1041
|
+
const r2 = this.mkIte(c2, v2, r3);
|
|
1042
|
+
return this.mkIte(c1, nan, r2);
|
|
1043
|
+
}
|
|
1044
|
+
|
|
1045
|
+
mkSqrt(sort: number, rm: number, x: number) {
|
|
1046
|
+
const manager = this.manager;
|
|
1047
|
+
const nan = this.mkNan(sort);
|
|
1048
|
+
this.mkNzero(sort);
|
|
1049
|
+
this.mkPzero(sort);
|
|
1050
|
+
this.mkNinf(sort);
|
|
1051
|
+
this.mkPinf(sort);
|
|
1052
|
+
const xIsNan = this.mkIsNan(x);
|
|
1053
|
+
this.mkIsZero(x);
|
|
1054
|
+
this.mkIsPos(x);
|
|
1055
|
+
this.mkIsInf(x);
|
|
1056
|
+
const zeroBit = this.num(0, 1);
|
|
1057
|
+
const oneBit = this.num(1, 1);
|
|
1058
|
+
const c2 = this.mkIsPinf(x);
|
|
1059
|
+
const c3 = this.mkIsZero(x);
|
|
1060
|
+
const c4 = this.mkIsNeg(x);
|
|
1061
|
+
const ebits = manager.getEbits(sort);
|
|
1062
|
+
const sbits = manager.getSbits(sort);
|
|
1063
|
+
const a = this.unpack(x, true);
|
|
1064
|
+
const aExpExt = this.signExtend(1, a.exp);
|
|
1065
|
+
const aLzExt = this.zeroExtend(1, a.lz);
|
|
1066
|
+
const realExp = this.bv(OP_BSUB, aExpExt, aLzExt);
|
|
1067
|
+
const resExp = this.signExtend(2, this.extract(ebits, 1, realExp));
|
|
1068
|
+
const eIsOdd = manager.mkEq(this.extract(0, 0, realExp), oneBit);
|
|
1069
|
+
const aZ = this.concat(a.sig, zeroBit);
|
|
1070
|
+
const zA = this.concat(zeroBit, a.sig);
|
|
1071
|
+
const sigPrime = this.simpIte(eIsOdd, aZ, zA);
|
|
1072
|
+
let q = this.num(1n << BigInt(sbits + 3), sbits + 5);
|
|
1073
|
+
let r = this.bv(OP_BSUB, this.concat(sigPrime, this.num(0, 4)), q);
|
|
1074
|
+
let s = q;
|
|
1075
|
+
for (let index = 0; index < sbits + 3; index++) {
|
|
1076
|
+
s = this.concat(zeroBit, this.extract(sbits + 4, 1, s));
|
|
1077
|
+
const twoQ = this.concat(q, zeroBit);
|
|
1078
|
+
const sExt = this.concat(zeroBit, s);
|
|
1079
|
+
const twoQPlusS = this.bv(OP_BADD, twoQ, sExt);
|
|
1080
|
+
const t = this.bv(OP_BSUB, this.concat(r, zeroBit), twoQPlusS);
|
|
1081
|
+
const tLsds5 = this.extract(sbits + 5, sbits + 5, t);
|
|
1082
|
+
const tLt0 = this.simpEq(tLsds5, oneBit);
|
|
1083
|
+
const qOrS = this.bv(OP_BOR, q, s);
|
|
1084
|
+
q = this.simpIte(tLt0, q, qOrS);
|
|
1085
|
+
const rShifted = this.concat(this.extract(sbits + 3, 0, r), zeroBit);
|
|
1086
|
+
const tLsds4 = this.extract(sbits + 4, 0, t);
|
|
1087
|
+
r = this.simpIte(tLt0, rShifted, tLsds4);
|
|
1088
|
+
}
|
|
1089
|
+
const zeroSbits5 = this.num(0, sbits + 5);
|
|
1090
|
+
const isExact = this.simpEq(r, zeroSbits5);
|
|
1091
|
+
const last = this.extract(0, 0, q);
|
|
1092
|
+
const rest = this.extract(sbits + 3, 1, q);
|
|
1093
|
+
const restExt = this.zeroExtend(1, rest);
|
|
1094
|
+
const lastExt = this.zeroExtend(sbits + 3, last);
|
|
1095
|
+
const oneSbits4 = this.num(1, sbits + 4);
|
|
1096
|
+
const sticky = this.simpIte(isExact, lastExt, oneSbits4);
|
|
1097
|
+
const resSig = this.bv(OP_BOR, restExt, sticky);
|
|
1098
|
+
const v5 = this.round(sort, rm, zeroBit, resSig, resExp);
|
|
1099
|
+
const r4 = this.mkIte(c4, nan, v5);
|
|
1100
|
+
const r3 = this.mkIte(c3, x, r4);
|
|
1101
|
+
const r2 = this.mkIte(c2, x, r3);
|
|
1102
|
+
return this.mkIte(xIsNan, x, r2);
|
|
1103
|
+
}
|
|
1104
|
+
|
|
1105
|
+
mkRoundToIntegral(sort: number, rm: number, x: number) {
|
|
1106
|
+
const manager = this.manager;
|
|
1107
|
+
const rmIsRta = this.mkIsRm(rm, BV_RM_TIES_TO_AWAY);
|
|
1108
|
+
const rmIsRte = this.mkIsRm(rm, BV_RM_TIES_TO_EVEN);
|
|
1109
|
+
const rmIsRtp = this.mkIsRm(rm, BV_RM_TO_POSITIVE);
|
|
1110
|
+
const rmIsRtn = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
1111
|
+
const rmIsRtz = this.mkIsRm(rm, BV_RM_TO_ZERO);
|
|
1112
|
+
const nan = this.mkNan(sort);
|
|
1113
|
+
const nzero = this.mkNzero(sort);
|
|
1114
|
+
const pzero = this.mkPzero(sort);
|
|
1115
|
+
this.mkIsZero(x);
|
|
1116
|
+
this.mkIsPos(x);
|
|
1117
|
+
const xIsNeg = this.mkIsNeg(x);
|
|
1118
|
+
const c1 = this.mkIsNan(x);
|
|
1119
|
+
const c2 = this.mkIsInf(x);
|
|
1120
|
+
const c3 = this.mkIsZero(x);
|
|
1121
|
+
const oneBit = this.num(1, 1);
|
|
1122
|
+
const zeroBit = this.num(0, 1);
|
|
1123
|
+
const ebits = manager.getEbits(sort);
|
|
1124
|
+
const sbits = manager.getSbits(sort);
|
|
1125
|
+
const a = this.unpack(x, true);
|
|
1126
|
+
const sgnEq1 = manager.mkEq(a.sgn, oneBit);
|
|
1127
|
+
const xzero = this.mkIte(sgnEq1, nzero, pzero);
|
|
1128
|
+
const xIsDenormal = this.mkIsDenormal(x);
|
|
1129
|
+
const expH = this.extract(ebits - 1, ebits - 1, a.exp);
|
|
1130
|
+
const expLtZero = this.simpEq(expH, oneBit);
|
|
1131
|
+
const c4 = this.mkOr(expLtZero, xIsDenormal);
|
|
1132
|
+
const pone = this.mkOne(sort, zeroBit);
|
|
1133
|
+
const none = this.mkOne(sort, oneBit);
|
|
1134
|
+
const xone = this.mkIte(sgnEq1, none, pone);
|
|
1135
|
+
const realExpExt = this.signExtend(1, a.exp);
|
|
1136
|
+
const aLzExt = this.zeroExtend(1, a.lz);
|
|
1137
|
+
const realExp = this.bv(OP_BSUB, realExpExt, aLzExt);
|
|
1138
|
+
const pow2Sbitsm1 = this.num(1n << BigInt(sbits - 1), sbits);
|
|
1139
|
+
const m1Ext = this.bv(OP_BNEG, this.num(1, ebits + 1));
|
|
1140
|
+
const t1 = this.simpEq(a.sig, pow2Sbitsm1);
|
|
1141
|
+
const t2 = this.simpEq(realExp, m1Ext);
|
|
1142
|
+
const tie = this.simpAnd(t1, t2);
|
|
1143
|
+
const c421 = this.simpAnd(tie, rmIsRte);
|
|
1144
|
+
const c422 = this.simpAnd(tie, rmIsRta);
|
|
1145
|
+
const c423 = this.bv(OP_SLEQ, realExp, this.bv(OP_BNEG, this.num(2, ebits + 1)));
|
|
1146
|
+
const v423 = this.mkIte(c423, xzero, xone);
|
|
1147
|
+
const v422 = this.mkIte(c422, xone, v423);
|
|
1148
|
+
const v42 = this.mkIte(c421, xzero, v422);
|
|
1149
|
+
const v4Rtp = this.mkIte(xIsNeg, nzero, pone);
|
|
1150
|
+
const v4Rtn = this.mkIte(xIsNeg, none, pzero);
|
|
1151
|
+
const v4p = this.mkIte(rmIsRtp, v4Rtp, v42);
|
|
1152
|
+
const v4n = this.mkIte(rmIsRtn, v4Rtn, v4p);
|
|
1153
|
+
const v4 = this.mkIte(rmIsRtz, xzero, v4n);
|
|
1154
|
+
const c5 =
|
|
1155
|
+
getLog2(sbits - 1) + 1 <= ebits - 1
|
|
1156
|
+
? this.bv(OP_SLEQ, this.num(sbits - 1, ebits), a.exp)
|
|
1157
|
+
: manager.falseExpr;
|
|
1158
|
+
const resSgn = a.sgn;
|
|
1159
|
+
const zeroS = this.num(0, sbits);
|
|
1160
|
+
const shiftBase = this.num(sbits - 1, sbits);
|
|
1161
|
+
const aExpExt = this.signExtend(sbits - ebits, a.exp);
|
|
1162
|
+
const shift = this.bv(OP_BSUB, shiftBase, aExpExt);
|
|
1163
|
+
const aSigExt = this.concat(a.sig, zeroS);
|
|
1164
|
+
const shiftExt = this.concat(zeroS, shift);
|
|
1165
|
+
const shiftedSig = this.bv(OP_BLSHR, aSigExt, shiftExt);
|
|
1166
|
+
const div = this.extract(2 * sbits - 1, sbits, shiftedSig);
|
|
1167
|
+
const rem = this.extract(sbits - 1, 0, shiftedSig);
|
|
1168
|
+
const divP1 = this.bv(OP_BADD, div, this.num(1, sbits));
|
|
1169
|
+
const tiePattern = this.concat(oneBit, this.num(0, sbits - 1));
|
|
1170
|
+
const tie2 = this.simpEq(rem, tiePattern);
|
|
1171
|
+
const divLast = this.extract(0, 0, div);
|
|
1172
|
+
const divLastEq1 = manager.mkEq(divLast, oneBit);
|
|
1173
|
+
const rteAndDlEq1 = this.mkAnd(rmIsRte, divLastEq1);
|
|
1174
|
+
const rteAndDlEq1OrRta = this.mkOr(rteAndDlEq1, rmIsRta);
|
|
1175
|
+
const tiePatternUleRem = this.bv(OP_ULEQ, tiePattern, rem);
|
|
1176
|
+
const tie2C = this.mkRawIte(tie2, rteAndDlEq1OrRta, tiePatternUleRem);
|
|
1177
|
+
const v51 = this.simpIte(tie2C, divP1, div);
|
|
1178
|
+
const remEq0 = manager.mkEq(rem, this.num(0, sbits));
|
|
1179
|
+
const sgnEqZero = manager.mkEq(resSgn, zeroBit);
|
|
1180
|
+
const c521 = this.simpAnd(this.simpNot(remEq0), sgnEqZero);
|
|
1181
|
+
const v52 = this.simpIte(c521, divP1, div);
|
|
1182
|
+
const sgnEqOne = manager.mkEq(resSgn, oneBit);
|
|
1183
|
+
const c531 = this.simpAnd(this.simpNot(remEq0), sgnEqOne);
|
|
1184
|
+
const v53 = this.simpIte(c531, divP1, div);
|
|
1185
|
+
const c51 = this.mkOr(rmIsRte, rmIsRta);
|
|
1186
|
+
const sig53 = this.simpIte(rmIsRtn, v53, div);
|
|
1187
|
+
const sig52 = this.simpIte(rmIsRtp, v52, sig53);
|
|
1188
|
+
const sig51 = this.simpIte(c51, v51, sig52);
|
|
1189
|
+
const eShift =
|
|
1190
|
+
ebits + 2 <= sbits
|
|
1191
|
+
? this.extract(ebits + 1, 0, shift)
|
|
1192
|
+
: this.signExtend(ebits + 2 - sbits, shift);
|
|
1193
|
+
const expSum = this.bv(OP_BADD, this.zeroExtend(2, a.exp), eShift);
|
|
1194
|
+
const zeroE2 = this.num(0, ebits + 2);
|
|
1195
|
+
const minExp = this.signExtend(2, this.mkMinExp(ebits));
|
|
1196
|
+
const sigLz = this.mkLeadingZeros(sig51, ebits + 2);
|
|
1197
|
+
const maxExpDelta = this.bv(OP_BSUB, expSum, minExp);
|
|
1198
|
+
const sigLzCapped = this.mkRawIte(this.bv(OP_ULEQ, sigLz, maxExpDelta), sigLz, maxExpDelta);
|
|
1199
|
+
const renormDelta = this.mkRawIte(this.bv(OP_ULEQ, zeroE2, sigLzCapped), sigLzCapped, zeroE2);
|
|
1200
|
+
const resExp = this.bv(OP_BSUB, expSum, renormDelta);
|
|
1201
|
+
const resSig =
|
|
1202
|
+
sbits >= ebits + 2
|
|
1203
|
+
? this.bv(OP_BSHL, sig51, this.zeroExtend(sbits - ebits - 2, renormDelta))
|
|
1204
|
+
: this.extract(
|
|
1205
|
+
sbits - 1,
|
|
1206
|
+
0,
|
|
1207
|
+
this.bv(OP_BSHL, this.zeroExtend(ebits + 2 - sbits, sig51), renormDelta),
|
|
1208
|
+
);
|
|
1209
|
+
const biasedExp = this.mkBias(this.extract(ebits - 1, 0, resExp));
|
|
1210
|
+
const v6 = this.mkFp(resSgn, biasedExp, this.extract(sbits - 2, 0, resSig));
|
|
1211
|
+
const r5 = this.mkIte(c5, x, v6);
|
|
1212
|
+
const r4 = this.mkIte(c4, v4, r5);
|
|
1213
|
+
const r3 = this.mkIte(c3, x, r4);
|
|
1214
|
+
const r2 = this.mkIte(c2, x, r3);
|
|
1215
|
+
return this.mkIte(c1, nan, r2);
|
|
1216
|
+
}
|
|
1217
|
+
|
|
1218
|
+
mkFloatEq(x: number, y: number) {
|
|
1219
|
+
const manager = this.manager;
|
|
1220
|
+
const xIsNan = this.mkIsNan(x);
|
|
1221
|
+
const yIsNan = this.mkIsNan(y);
|
|
1222
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
1223
|
+
const xIsZero = this.mkIsZero(x);
|
|
1224
|
+
const yIsZero = this.mkIsZero(y);
|
|
1225
|
+
const c2 = this.simpAnd(xIsZero, yIsZero);
|
|
1226
|
+
const [xSgn, xExp, xSig] = this.splitFp(x);
|
|
1227
|
+
const [ySgn, yExp, ySig] = this.splitFp(y);
|
|
1228
|
+
const xEqYSgn = this.simpEq(xSgn, ySgn);
|
|
1229
|
+
const xEqYExp = this.simpEq(xExp, yExp);
|
|
1230
|
+
const xEqYSig = this.simpEq(xSig, ySig);
|
|
1231
|
+
const c3 = this.simpNot(xEqYSgn);
|
|
1232
|
+
const t4 = this.simpAnd(xEqYExp, xEqYSig);
|
|
1233
|
+
const c3t4 = this.simpIte(c3, manager.falseExpr, t4);
|
|
1234
|
+
const c2Else = this.simpIte(c2, manager.trueExpr, c3t4);
|
|
1235
|
+
return this.simpIte(c1, manager.falseExpr, c2Else);
|
|
1236
|
+
}
|
|
1237
|
+
|
|
1238
|
+
mkFloatLt(x: number, y: number) {
|
|
1239
|
+
const manager = this.manager;
|
|
1240
|
+
const xIsNan = this.mkIsNan(x);
|
|
1241
|
+
const yIsNan = this.mkIsNan(y);
|
|
1242
|
+
const c1 = this.simpOr(xIsNan, yIsNan);
|
|
1243
|
+
const xIsZero = this.mkIsZero(x);
|
|
1244
|
+
const yIsZero = this.mkIsZero(y);
|
|
1245
|
+
const c2 = this.simpAnd(xIsZero, yIsZero);
|
|
1246
|
+
const [xSgn, xExp, xSig] = this.splitFp(x);
|
|
1247
|
+
const [ySgn, yExp, ySig] = this.splitFp(y);
|
|
1248
|
+
const oneBit = this.num(1, 1);
|
|
1249
|
+
const nilBit = this.num(0, 1);
|
|
1250
|
+
const c3 = this.simpEq(xSgn, oneBit);
|
|
1251
|
+
const ySgnEq0 = this.simpEq(ySgn, nilBit);
|
|
1252
|
+
const yLtXExp = this.bvUlt(yExp, xExp);
|
|
1253
|
+
const yLtXSig = this.bvUlt(ySig, xSig);
|
|
1254
|
+
const yEqXExp = this.simpEq(yExp, xExp);
|
|
1255
|
+
const yLeXSigExp = this.simpAnd(yEqXExp, yLtXSig);
|
|
1256
|
+
const t3Or = this.simpOr(yLtXExp, yLeXSigExp);
|
|
1257
|
+
const t3 = this.simpIte(ySgnEq0, manager.trueExpr, t3Or);
|
|
1258
|
+
const ySgnEq1 = this.simpEq(ySgn, oneBit);
|
|
1259
|
+
const xLtYExp = this.bvUlt(xExp, yExp);
|
|
1260
|
+
const xEqYExp = this.simpEq(xExp, yExp);
|
|
1261
|
+
const xLtYSig = this.bvUlt(xSig, ySig);
|
|
1262
|
+
const xLeYSigExp = this.simpAnd(xEqYExp, xLtYSig);
|
|
1263
|
+
const t4Or = this.simpOr(xLtYExp, xLeYSigExp);
|
|
1264
|
+
const t4 = this.simpIte(ySgnEq1, manager.falseExpr, t4Or);
|
|
1265
|
+
const c3t3t4 = this.simpIte(c3, t3, t4);
|
|
1266
|
+
const c2Else = this.simpIte(c2, manager.falseExpr, c3t3t4);
|
|
1267
|
+
return this.simpIte(c1, manager.falseExpr, c2Else);
|
|
1268
|
+
}
|
|
1269
|
+
|
|
1270
|
+
mkFloatGt(x: number, y: number) {
|
|
1271
|
+
const manager = this.manager;
|
|
1272
|
+
const t3 = this.mkFloatLe(x, y);
|
|
1273
|
+
const xIsNan = this.mkIsNan(x);
|
|
1274
|
+
const yIsNan = this.mkIsNan(y);
|
|
1275
|
+
const nanOr = this.simpOr(xIsNan, yIsNan);
|
|
1276
|
+
const xIsZero = this.mkIsZero(x);
|
|
1277
|
+
const yIsZero = this.mkIsZero(y);
|
|
1278
|
+
const xyZero = this.simpAnd(xIsZero, yIsZero);
|
|
1279
|
+
const notT3 = this.simpNot(t3);
|
|
1280
|
+
const rElse = this.simpIte(xyZero, manager.falseExpr, notT3);
|
|
1281
|
+
return this.simpIte(nanOr, manager.falseExpr, rElse);
|
|
1282
|
+
}
|
|
1283
|
+
|
|
1284
|
+
mkFloatLe(x: number, y: number) {
|
|
1285
|
+
const lt = this.mkFloatLt(x, y);
|
|
1286
|
+
const eq = this.mkFloatEq(x, y);
|
|
1287
|
+
return this.simpOr(lt, eq);
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
mkFloatGe(x: number, y: number) {
|
|
1291
|
+
const gt = this.mkFloatGt(x, y);
|
|
1292
|
+
const eq = this.mkFloatEq(x, y);
|
|
1293
|
+
return this.simpOr(gt, eq);
|
|
1294
|
+
}
|
|
1295
|
+
|
|
1296
|
+
mkIsNegative(x: number) {
|
|
1297
|
+
const manager = this.manager;
|
|
1298
|
+
const isNan = this.mkIsNan(x);
|
|
1299
|
+
const isNeg = this.mkIsNeg(x);
|
|
1300
|
+
return this.mkAnd(manager.mkNot(isNan), isNeg);
|
|
1301
|
+
}
|
|
1302
|
+
|
|
1303
|
+
mkIsPositive(x: number) {
|
|
1304
|
+
const manager = this.manager;
|
|
1305
|
+
const isNan = this.mkIsNan(x);
|
|
1306
|
+
const isPos = this.mkIsPos(x);
|
|
1307
|
+
return this.mkAnd(manager.mkNot(isNan), isPos);
|
|
1308
|
+
}
|
|
1309
|
+
|
|
1310
|
+
mkToFp(sort: number, args: number[]) {
|
|
1311
|
+
const manager = this.manager;
|
|
1312
|
+
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
1313
|
+
if (args.length === 1) {
|
|
1314
|
+
const size = this.getBvSize(args[0]);
|
|
1315
|
+
const toEbits = manager.getEbits(sort);
|
|
1316
|
+
const sgn = this.extract(size - 1, size - 1, args[0]);
|
|
1317
|
+
const exp = this.extract(size - 2, size - toEbits - 1, args[0]);
|
|
1318
|
+
const sig = this.extract(size - toEbits - 2, 0, args[0]);
|
|
1319
|
+
return this.mkFp(sgn, exp, sig);
|
|
1320
|
+
}
|
|
1321
|
+
if (args.length === 2 && manager.isFpSort(argSorts[1]))
|
|
1322
|
+
return this.mkToFpFloat(sort, manager.getArg(args[0], 0), args[1]);
|
|
1323
|
+
if (args.length === 2 && (argSorts[1] === SORT_INT || argSorts[1] === SORT_REAL))
|
|
1324
|
+
return this.mkToFpReal(sort, manager.getArg(args[0], 0), args[1]);
|
|
1325
|
+
if (args.length === 2) return this.mkToFpSigned(sort, manager.getArg(args[0], 0), args[1]);
|
|
1326
|
+
if (manager.isBvSort(argSorts[0])) return this.mkFp(args[0], args[1], args[2]);
|
|
1327
|
+
if (manager.getOp(args[1]) === OP_NUM && manager.getOp(args[2]) === OP_NUM) {
|
|
1328
|
+
const isIntReal = argSorts[1] === SORT_INT && argSorts[2] === SORT_REAL;
|
|
1329
|
+
const exponent = manager.getRationalValue(isIntReal ? args[1] : args[2]).num;
|
|
1330
|
+
const significand = manager.getRationalValue(isIntReal ? args[2] : args[1]);
|
|
1331
|
+
return this.mkToFpRealInt(sort, manager.getArg(args[0], 0), exponent, significand);
|
|
1332
|
+
}
|
|
1333
|
+
throw new SmtUnsupportedError("floating-point conversion of a non-numeral real");
|
|
1334
|
+
}
|
|
1335
|
+
|
|
1336
|
+
mkToFpFloat(sort: number, rm: number, x: number) {
|
|
1337
|
+
const manager = this.manager;
|
|
1338
|
+
const xSort = manager.sorts[x];
|
|
1339
|
+
const fromSbits = manager.getSbits(xSort);
|
|
1340
|
+
const fromEbits = manager.getEbits(xSort);
|
|
1341
|
+
const toSbits = manager.getSbits(sort);
|
|
1342
|
+
const toEbits = manager.getEbits(sort);
|
|
1343
|
+
if (fromSbits === toSbits && fromEbits === toEbits) return x;
|
|
1344
|
+
const oneBit = this.num(1, 1);
|
|
1345
|
+
const pinf = this.mkPinf(sort);
|
|
1346
|
+
const ninf = this.mkNinf(sort);
|
|
1347
|
+
const c1 = this.mkIsNan(x);
|
|
1348
|
+
const v1 = this.mkNan(sort);
|
|
1349
|
+
const c2 = this.mkIsPzero(x);
|
|
1350
|
+
const v2 = this.mkPzero(sort);
|
|
1351
|
+
const c3 = this.mkIsNzero(x);
|
|
1352
|
+
const v3 = this.mkNzero(sort);
|
|
1353
|
+
const c4 = this.mkIsPinf(x);
|
|
1354
|
+
const c5 = this.mkIsNinf(x);
|
|
1355
|
+
const unpacked = this.unpack(x, true);
|
|
1356
|
+
const sig = unpacked.sig;
|
|
1357
|
+
const truncatedSig =
|
|
1358
|
+
fromSbits < toSbits + 3
|
|
1359
|
+
? this.concat(sig, this.num(0, toSbits + 3 - fromSbits))
|
|
1360
|
+
: fromSbits > toSbits + 3
|
|
1361
|
+
? this.concat(
|
|
1362
|
+
this.extract(fromSbits - 1, fromSbits - toSbits - 2, sig),
|
|
1363
|
+
this.bv(OP_BREDOR, this.extract(fromSbits - toSbits - 3, 0, sig)),
|
|
1364
|
+
)
|
|
1365
|
+
: sig;
|
|
1366
|
+
const resSig = this.zeroExtend(1, truncatedSig);
|
|
1367
|
+
const exponentOverflow = manager.falseExpr;
|
|
1368
|
+
let resExp: number;
|
|
1369
|
+
if (fromEbits < toEbits + 2) {
|
|
1370
|
+
const extended = this.signExtend(toEbits - fromEbits + 2, unpacked.exp);
|
|
1371
|
+
const lzExt = this.zeroExtend(toEbits - fromEbits + 2, unpacked.lz);
|
|
1372
|
+
resExp = this.bv(OP_BSUB, extended, lzExt);
|
|
1373
|
+
} else {
|
|
1374
|
+
const ebitsDiff = fromEbits - (toEbits + 2);
|
|
1375
|
+
const expExt = this.signExtend(2, unpacked.exp);
|
|
1376
|
+
const lzExt = this.signExtend(2, unpacked.lz);
|
|
1377
|
+
const expSubLz = this.bv(OP_BSUB, expExt, lzExt);
|
|
1378
|
+
const maxExp = this.concat(
|
|
1379
|
+
this.num(getPowerOfTwoMinusOne(toEbits), toEbits + 1),
|
|
1380
|
+
this.num(0, 1),
|
|
1381
|
+
);
|
|
1382
|
+
const minExp = this.num(-(1n << BigInt(toEbits + 1)) + 2n, toEbits + 2);
|
|
1383
|
+
const firstOvfExp = this.num(getPowerOfTwoMinusOne(toEbits + 1), fromEbits + 2);
|
|
1384
|
+
const udfHigh = this.bv(OP_BNEG, this.num(1, ebitsDiff + 3));
|
|
1385
|
+
const udfLow = this.num(1, toEbits + 1);
|
|
1386
|
+
const firstUdfExp = this.concat(udfHigh, udfLow);
|
|
1387
|
+
const expInRange = this.extract(toEbits + 1, 0, expSubLz);
|
|
1388
|
+
const ovfCond = this.bv(OP_SLEQ, firstOvfExp, expSubLz);
|
|
1389
|
+
const udfCond = this.bv(OP_SLEQ, expSubLz, firstUdfExp);
|
|
1390
|
+
resExp = this.mkRawIte(udfCond, minExp, this.mkRawIte(ovfCond, maxExp, expInRange));
|
|
1391
|
+
}
|
|
1392
|
+
const rounded = this.round(sort, rm, unpacked.sgn, resSig, resExp);
|
|
1393
|
+
const isNeg = this.simpEq(unpacked.sgn, oneBit);
|
|
1394
|
+
const sigInf = this.mkIte(isNeg, ninf, pinf);
|
|
1395
|
+
const v6 = this.mkIte(exponentOverflow, sigInf, rounded);
|
|
1396
|
+
const r5 = this.mkIte(c5, ninf, v6);
|
|
1397
|
+
const r4 = this.mkIte(c4, pinf, r5);
|
|
1398
|
+
const r3 = this.mkIte(c3, v3, r4);
|
|
1399
|
+
const r2 = this.mkIte(c2, v2, r3);
|
|
1400
|
+
return this.mkIte(c1, v1, r2);
|
|
1401
|
+
}
|
|
1402
|
+
|
|
1403
|
+
private mkFpOfMpf(value: Mpf) {
|
|
1404
|
+
const sgn = this.num(value.sign ? 1 : 0, 1);
|
|
1405
|
+
const sig = this.num(value.significand, value.sbits - 1);
|
|
1406
|
+
const exp = this.mkBias(this.num(value.exponent, value.ebits));
|
|
1407
|
+
return this.mkFp(sgn, exp, sig);
|
|
1408
|
+
}
|
|
1409
|
+
|
|
1410
|
+
mkToFpReal(sort: number, rm: number, x: number) {
|
|
1411
|
+
const manager = this.manager;
|
|
1412
|
+
const ebits = manager.getEbits(sort);
|
|
1413
|
+
const sbits = manager.getSbits(sort);
|
|
1414
|
+
if (manager.getOp(x) !== OP_NUM) return this.mkToFpSymbolicReal(sort, rm, x);
|
|
1415
|
+
const value = manager.getRationalValue(x);
|
|
1416
|
+
if (value.isZero()) return this.mkPzero(sort);
|
|
1417
|
+
if (manager.isBvNumeral(rm)) {
|
|
1418
|
+
const mode = Number(manager.getBvNumeralValue(rm));
|
|
1419
|
+
return this.mkFpOfMpf(
|
|
1420
|
+
mpfFromRational(ebits, sbits, mode > BV_RM_TO_ZERO ? BV_RM_TO_ZERO : mode, 0n, value),
|
|
1421
|
+
);
|
|
1422
|
+
}
|
|
1423
|
+
const rmNta = this.mkIsRm(rm, BV_RM_TIES_TO_AWAY);
|
|
1424
|
+
const rmNte = this.mkIsRm(rm, BV_RM_TIES_TO_EVEN);
|
|
1425
|
+
const rmTp = this.mkIsRm(rm, BV_RM_TO_POSITIVE);
|
|
1426
|
+
const rmTn = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
1427
|
+
this.mkIsRm(rm, BV_RM_TO_ZERO);
|
|
1428
|
+
const v1 = this.mkFpOfMpf(mpfFromRational(ebits, sbits, BV_RM_TIES_TO_AWAY, 0n, value));
|
|
1429
|
+
const v2 = this.mkFpOfMpf(mpfFromRational(ebits, sbits, BV_RM_TIES_TO_EVEN, 0n, value));
|
|
1430
|
+
const v3 = this.mkFpOfMpf(mpfFromRational(ebits, sbits, BV_RM_TO_POSITIVE, 0n, value));
|
|
1431
|
+
const v4 = this.mkFpOfMpf(mpfFromRational(ebits, sbits, BV_RM_TO_NEGATIVE, 0n, value));
|
|
1432
|
+
const v5 = this.mkFpOfMpf(mpfFromRational(ebits, sbits, BV_RM_TO_ZERO, 0n, value));
|
|
1433
|
+
const r4 = this.mkIte(rmTn, v4, v5);
|
|
1434
|
+
const r3 = this.mkIte(rmTp, v3, r4);
|
|
1435
|
+
const r2 = this.mkIte(rmNte, v2, r3);
|
|
1436
|
+
return this.mkIte(rmNta, v1, r2);
|
|
1437
|
+
}
|
|
1438
|
+
|
|
1439
|
+
private mkToFpSymbolicReal(sort: number, rm: number, input: number) {
|
|
1440
|
+
const manager = this.manager;
|
|
1441
|
+
const ebits = manager.getEbits(sort);
|
|
1442
|
+
const sbits = manager.getSbits(sort);
|
|
1443
|
+
// Deviation from Z3: it runs out of memory from an exponent width of 31, where this gives up as at a resource limit.
|
|
1444
|
+
if (ebits > 30) throw new SmtCanceledError();
|
|
1445
|
+
const x =
|
|
1446
|
+
manager.sorts[input] === SORT_INT ? manager.mkApp(OP_TO_REAL, [input], SORT_REAL) : input;
|
|
1447
|
+
const real = (op: number, ...args: number[]) => manager.mkApp(op, args, SORT_REAL);
|
|
1448
|
+
const bool = (op: number, ...args: number[]) => manager.mkApp(op, args, SORT_BOOL);
|
|
1449
|
+
const mkReal = (value: Rational) => manager.mkRealNumeral(value);
|
|
1450
|
+
const mkAbs = (expr: number) =>
|
|
1451
|
+
this.mkRawIte(bool(OP_LT, expr, zero), real(OP_UMINUS, expr), expr);
|
|
1452
|
+
const bv0 = this.num(0, 1);
|
|
1453
|
+
const bv1 = this.num(1, 1);
|
|
1454
|
+
const zero = mkReal(Rational.of(0n));
|
|
1455
|
+
const two = mkReal(Rational.of(2n));
|
|
1456
|
+
const result = this.round(
|
|
1457
|
+
sort,
|
|
1458
|
+
rm,
|
|
1459
|
+
manager.mkFreshConst("fpa2bv_to_fp_real_sgn", manager.mkBvSort(1)),
|
|
1460
|
+
manager.mkFreshConst("fpa2bv_to_fp_real_sig", manager.mkBvSort(sbits + 4)),
|
|
1461
|
+
manager.mkFreshConst("fpa2bv_to_fp_real_exp", manager.mkBvSort(ebits + 2)),
|
|
1462
|
+
);
|
|
1463
|
+
const rIsNan = this.mkIsNan(result);
|
|
1464
|
+
this.extraAssertions.push(manager.mkNot(rIsNan));
|
|
1465
|
+
const maxExp = getPowerOfTwoMinusOne(ebits - 1);
|
|
1466
|
+
const maxReal = Rational.of(getPowerOfTwoMinusOne(sbits) << maxExp, 1n << BigInt(sbits - 1));
|
|
1467
|
+
const nearestMaxReal = Rational.of(1n << maxExp, 1n << BigInt(sbits)).add(maxReal);
|
|
1468
|
+
const rIsPinf = this.mkIsPinf(result);
|
|
1469
|
+
const rIsNinf = this.mkIsNinf(result);
|
|
1470
|
+
const eMaxReal = mkReal(maxReal);
|
|
1471
|
+
const eMaxRealNeg = mkReal(maxReal.neg());
|
|
1472
|
+
const eNearestMaxReal = mkReal(nearestMaxReal);
|
|
1473
|
+
const eNearestMaxRealNeg = mkReal(nearestMaxReal.neg());
|
|
1474
|
+
const rmNta = this.mkIsRm(rm, BV_RM_TIES_TO_AWAY);
|
|
1475
|
+
const rmNte = this.mkIsRm(rm, BV_RM_TIES_TO_EVEN);
|
|
1476
|
+
const rmTp = this.mkIsRm(rm, BV_RM_TO_POSITIVE);
|
|
1477
|
+
const rmTn = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
1478
|
+
this.mkIsRm(rm, BV_RM_TO_ZERO);
|
|
1479
|
+
const [rSgn, rExp, rSig] = this.splitFp(result);
|
|
1480
|
+
let sigField = zero;
|
|
1481
|
+
for (let index = 0; index < sbits - 1; index++) {
|
|
1482
|
+
const isOne = manager.mkEq(this.extract(index, index, rSig), bv1);
|
|
1483
|
+
const weight = mkReal(Rational.of(1n << BigInt(index)));
|
|
1484
|
+
sigField = real(OP_ADD, sigField, this.mkRawIte(isOne, weight, zero));
|
|
1485
|
+
}
|
|
1486
|
+
const expIsZero = manager.mkEq(rExp, this.num(0, ebits));
|
|
1487
|
+
const expIsOne = manager.mkEq(rExp, this.num(1, ebits));
|
|
1488
|
+
const sigIsZero = manager.mkEq(rSig, this.num(0, sbits - 1));
|
|
1489
|
+
const sigIsEven = manager.mkEq(this.extract(0, 0, rSig), bv0);
|
|
1490
|
+
const minSubnormal = Rational.of(1n, (1n << maxExp) << BigInt(sbits - 2));
|
|
1491
|
+
const sigValue = real(OP_ADD, mkReal(Rational.of(1n << BigInt(sbits - 1))), sigField);
|
|
1492
|
+
const absR = mkAbs(mkFpaApp(manager, OP_FPA_TO_REAL, [result]));
|
|
1493
|
+
const absX = mkAbs(x);
|
|
1494
|
+
const gapUp = this.mkRawIte(expIsZero, mkReal(minSubnormal), real(OP_DIV, absR, sigValue));
|
|
1495
|
+
const gapDown = this.mkRawIte(
|
|
1496
|
+
this.mkOr(expIsZero, expIsOne, manager.mkNot(sigIsZero)),
|
|
1497
|
+
gapUp,
|
|
1498
|
+
real(OP_DIV, gapUp, two),
|
|
1499
|
+
);
|
|
1500
|
+
const lowerMid = real(OP_SUB, absR, real(OP_DIV, gapDown, two));
|
|
1501
|
+
const upperMid = real(OP_ADD, absR, real(OP_DIV, gapUp, two));
|
|
1502
|
+
const inNearestRange = this.mkAnd(bool(OP_LE, lowerMid, absX), bool(OP_LE, absX, upperMid));
|
|
1503
|
+
const tieLo = manager.mkEq(absX, lowerMid);
|
|
1504
|
+
const tieHi = manager.mkEq(absX, upperMid);
|
|
1505
|
+
const nteCond = this.mkAnd(
|
|
1506
|
+
inNearestRange,
|
|
1507
|
+
bool(OP_IMPLIES, this.mkOr(tieLo, tieHi), sigIsEven),
|
|
1508
|
+
);
|
|
1509
|
+
const ntaCond = this.mkAnd(inNearestRange, manager.mkNot(tieHi));
|
|
1510
|
+
const isMaxFinite = this.mkAnd(
|
|
1511
|
+
manager.mkEq(rExp, this.num((1n << BigInt(ebits)) - 2n, ebits)),
|
|
1512
|
+
manager.mkEq(rSig, this.num(getPowerOfTwoMinusOne(sbits - 1), sbits - 1)),
|
|
1513
|
+
);
|
|
1514
|
+
const awayCond = this.mkAnd(
|
|
1515
|
+
bool(OP_LE, absX, absR),
|
|
1516
|
+
bool(OP_LT, real(OP_SUB, absR, gapDown), absX),
|
|
1517
|
+
);
|
|
1518
|
+
const toZeroCond = this.mkAnd(
|
|
1519
|
+
bool(OP_LE, absR, absX),
|
|
1520
|
+
this.mkOr(bool(OP_LT, absX, real(OP_ADD, absR, gapUp)), isMaxFinite),
|
|
1521
|
+
);
|
|
1522
|
+
const xIsNonneg = bool(OP_GE, x, zero);
|
|
1523
|
+
const tpCond = this.mkRawIte(xIsNonneg, awayCond, toZeroCond);
|
|
1524
|
+
const tnCond = this.mkRawIte(xIsNonneg, toZeroCond, awayCond);
|
|
1525
|
+
const roundingCond = this.mkRawIte(
|
|
1526
|
+
rmNta,
|
|
1527
|
+
ntaCond,
|
|
1528
|
+
this.mkRawIte(
|
|
1529
|
+
rmNte,
|
|
1530
|
+
nteCond,
|
|
1531
|
+
this.mkRawIte(rmTp, tpCond, this.mkRawIte(rmTn, tnCond, toZeroCond)),
|
|
1532
|
+
),
|
|
1533
|
+
);
|
|
1534
|
+
const rIsInf = this.mkIsInf(result);
|
|
1535
|
+
this.extraAssertions.push(
|
|
1536
|
+
bool(OP_IMPLIES, manager.mkNot(this.mkOr(rIsNan, rIsInf)), roundingCond),
|
|
1537
|
+
);
|
|
1538
|
+
const xIsPos = bool(OP_GT, x, zero);
|
|
1539
|
+
const xIsNeg = bool(OP_LT, x, zero);
|
|
1540
|
+
this.extraAssertions.push(bool(OP_IMPLIES, xIsPos, manager.mkEq(rSgn, bv0)));
|
|
1541
|
+
this.extraAssertions.push(bool(OP_IMPLIES, xIsNeg, manager.mkEq(rSgn, bv1)));
|
|
1542
|
+
const roundsToNearest = this.mkOr(rmNte, rmNta);
|
|
1543
|
+
const impliesGtMaxReal = bool(
|
|
1544
|
+
OP_IMPLIES,
|
|
1545
|
+
rIsPinf,
|
|
1546
|
+
this.mkOr(
|
|
1547
|
+
this.mkAnd(rmTp, bool(OP_GT, x, eMaxReal)),
|
|
1548
|
+
this.mkAnd(roundsToNearest, bool(OP_GE, x, eNearestMaxReal)),
|
|
1549
|
+
),
|
|
1550
|
+
);
|
|
1551
|
+
const impliesLtMinReal = bool(
|
|
1552
|
+
OP_IMPLIES,
|
|
1553
|
+
rIsNinf,
|
|
1554
|
+
this.mkOr(
|
|
1555
|
+
this.mkAnd(rmTn, bool(OP_LT, x, eMaxRealNeg)),
|
|
1556
|
+
this.mkAnd(roundsToNearest, bool(OP_LE, x, eNearestMaxRealNeg)),
|
|
1557
|
+
),
|
|
1558
|
+
);
|
|
1559
|
+
this.extraAssertions.push(impliesGtMaxReal);
|
|
1560
|
+
this.extraAssertions.push(impliesLtMinReal);
|
|
1561
|
+
const pzero = this.mkPzero(sort);
|
|
1562
|
+
this.extraAssertions.push(bool(OP_IMPLIES, manager.mkEq(x, zero), manager.mkEq(result, pzero)));
|
|
1563
|
+
return result;
|
|
1564
|
+
}
|
|
1565
|
+
|
|
1566
|
+
private mkToFpRealInt(sort: number, rm: number, exponent: bigint, significand: Rational) {
|
|
1567
|
+
const manager = this.manager;
|
|
1568
|
+
const ebits = manager.getEbits(sort);
|
|
1569
|
+
const sbits = manager.getSbits(sort);
|
|
1570
|
+
if (significand.isZero()) return this.mkPzero(sort);
|
|
1571
|
+
const getValue = (mode: number) =>
|
|
1572
|
+
this.mkNumeral(sort, mpfFromRational(ebits, sbits, mode, exponent, significand));
|
|
1573
|
+
const nte = getValue(BV_RM_TIES_TO_EVEN);
|
|
1574
|
+
const nta = getValue(BV_RM_TIES_TO_AWAY);
|
|
1575
|
+
const tp = getValue(BV_RM_TO_POSITIVE);
|
|
1576
|
+
const tn = getValue(BV_RM_TO_NEGATIVE);
|
|
1577
|
+
const tz = getValue(BV_RM_TO_ZERO);
|
|
1578
|
+
const c1 = manager.mkEq(rm, this.num(BV_RM_TO_NEGATIVE, 3));
|
|
1579
|
+
const c2 = manager.mkEq(rm, this.num(BV_RM_TO_POSITIVE, 3));
|
|
1580
|
+
const c3 = manager.mkEq(rm, this.num(BV_RM_TIES_TO_AWAY, 3));
|
|
1581
|
+
const c4 = manager.mkEq(rm, this.num(BV_RM_TIES_TO_EVEN, 3));
|
|
1582
|
+
const r1 = this.mkIte(c1, tn, tz);
|
|
1583
|
+
const r2 = this.mkIte(c2, tp, r1);
|
|
1584
|
+
const r3 = this.mkIte(c3, nta, r2);
|
|
1585
|
+
return this.mkIte(c4, nte, r3);
|
|
1586
|
+
}
|
|
1587
|
+
|
|
1588
|
+
mkToReal(decl: number, x: number) {
|
|
1589
|
+
const manager = this.manager;
|
|
1590
|
+
const sort = manager.sorts[x];
|
|
1591
|
+
const ebits = manager.getEbits(sort);
|
|
1592
|
+
const sbits = manager.getSbits(sort);
|
|
1593
|
+
const real = (op: number, ...args: number[]) => manager.mkApp(op, args, SORT_REAL);
|
|
1594
|
+
const isBitOne = (expr: number, index: number) =>
|
|
1595
|
+
manager.mkEq(this.extract(index, index, expr), bv1);
|
|
1596
|
+
const xIsNan = this.mkIsNan(x);
|
|
1597
|
+
const xIsInf = this.mkIsInf(x);
|
|
1598
|
+
const xIsZero = this.mkIsZero(x);
|
|
1599
|
+
const unpacked = this.unpack(x, true);
|
|
1600
|
+
const zero = manager.mkRealNumeral(Rational.of(0n));
|
|
1601
|
+
const one = manager.mkRealNumeral(Rational.of(1n));
|
|
1602
|
+
const two = manager.mkRealNumeral(Rational.of(2n));
|
|
1603
|
+
this.num(0, 1);
|
|
1604
|
+
const bv1 = this.num(1, 1);
|
|
1605
|
+
let rsig = one;
|
|
1606
|
+
for (let index = sbits - 2; index >= 0; index--) {
|
|
1607
|
+
const bitIsOne = isBitOne(unpacked.sig, index);
|
|
1608
|
+
rsig = real(OP_ADD, real(OP_MUL, rsig, two), this.mkRawIte(bitIsOne, one, zero));
|
|
1609
|
+
}
|
|
1610
|
+
const ep2 = manager.mkRealNumeral(Rational.of(1n << BigInt(sbits - 1)));
|
|
1611
|
+
rsig = real(OP_DIV, rsig, ep2);
|
|
1612
|
+
const expP = this.bv(
|
|
1613
|
+
OP_BSUB,
|
|
1614
|
+
this.signExtend(1, unpacked.exp),
|
|
1615
|
+
this.zeroExtend(1, unpacked.lz),
|
|
1616
|
+
);
|
|
1617
|
+
const expIsNeg = isBitOne(expP, ebits);
|
|
1618
|
+
const expAbs = this.mkRawIte(expIsNeg, this.bv(OP_BNEG, expP), expP);
|
|
1619
|
+
let exp2 = zero;
|
|
1620
|
+
for (let index = ebits; index >= 0; index--) {
|
|
1621
|
+
const bitIsOne = isBitOne(expAbs, index);
|
|
1622
|
+
exp2 = real(OP_ADD, real(OP_MUL, exp2, two), this.mkRawIte(bitIsOne, one, zero));
|
|
1623
|
+
}
|
|
1624
|
+
const twoExp2 = real(OP_POWER, two, exp2);
|
|
1625
|
+
const scale = this.mkRawIte(expIsNeg, real(OP_DIV, one, twoExp2), twoExp2);
|
|
1626
|
+
const magnitude = real(OP_MUL, rsig, scale);
|
|
1627
|
+
const negated = real(OP_UMINUS, magnitude);
|
|
1628
|
+
const sgnIsOne = manager.mkEq(unpacked.sgn, bv1);
|
|
1629
|
+
const value = this.mkRawIte(sgnIsOne, negated, magnitude);
|
|
1630
|
+
const wrapped = this.nanWrap(x);
|
|
1631
|
+
const unspecified = manager.mkApp(
|
|
1632
|
+
this.mkBvUf(decl, [manager.sorts[wrapped]], SORT_REAL),
|
|
1633
|
+
[wrapped],
|
|
1634
|
+
SORT_REAL,
|
|
1635
|
+
);
|
|
1636
|
+
const result = this.mkRawIte(
|
|
1637
|
+
xIsNan,
|
|
1638
|
+
unspecified,
|
|
1639
|
+
this.mkRawIte(xIsInf, unspecified, this.mkRawIte(xIsZero, zero, value)),
|
|
1640
|
+
);
|
|
1641
|
+
const notSpecial = manager.mkNot(this.mkOr(xIsNan, xIsInf, xIsZero));
|
|
1642
|
+
this.extraAssertions.push(
|
|
1643
|
+
manager.mkApp(
|
|
1644
|
+
OP_IMPLIES,
|
|
1645
|
+
[this.mkAnd(notSpecial, sgnIsOne), manager.mkApp(OP_LT, [result, zero], SORT_BOOL)],
|
|
1646
|
+
SORT_BOOL,
|
|
1647
|
+
),
|
|
1648
|
+
);
|
|
1649
|
+
this.extraAssertions.push(
|
|
1650
|
+
manager.mkApp(
|
|
1651
|
+
OP_IMPLIES,
|
|
1652
|
+
[
|
|
1653
|
+
this.mkAnd(notSpecial, manager.mkNot(sgnIsOne)),
|
|
1654
|
+
manager.mkApp(OP_GT, [result, zero], SORT_BOOL),
|
|
1655
|
+
],
|
|
1656
|
+
SORT_BOOL,
|
|
1657
|
+
),
|
|
1658
|
+
);
|
|
1659
|
+
return result;
|
|
1660
|
+
}
|
|
1661
|
+
|
|
1662
|
+
private mkToFpBits(sort: number, rm: number, x: number, isSigned: boolean) {
|
|
1663
|
+
const manager = this.manager;
|
|
1664
|
+
const ebits = manager.getEbits(sort);
|
|
1665
|
+
const sbits = manager.getSbits(sort);
|
|
1666
|
+
const inputSize = this.getBvSize(x);
|
|
1667
|
+
this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
1668
|
+
const signOrZeroBit = this.num(isSigned ? 1 : 0, 1);
|
|
1669
|
+
const zeroSize = this.num(0, inputSize);
|
|
1670
|
+
const isZero = manager.mkEq(x, zeroSize);
|
|
1671
|
+
const pzero = this.mkPzero(sort);
|
|
1672
|
+
this.mkNzero(sort);
|
|
1673
|
+
let sgn = signOrZeroBit;
|
|
1674
|
+
let abs = x;
|
|
1675
|
+
if (isSigned) {
|
|
1676
|
+
sgn = this.extract(inputSize - 1, inputSize - 1, x);
|
|
1677
|
+
this.extract(inputSize === 1 ? 0 : inputSize - 2, 0, x);
|
|
1678
|
+
const isNeg = manager.mkEq(sgn, signOrZeroBit);
|
|
1679
|
+
const negX = this.bv(OP_BNEG, x);
|
|
1680
|
+
abs = this.mkRawIte(isNeg, negX, x);
|
|
1681
|
+
}
|
|
1682
|
+
let lz = this.mkLeadingZeros(abs, inputSize);
|
|
1683
|
+
const shiftedSig = this.bv(OP_BSHL, abs, lz);
|
|
1684
|
+
const sigSize = sbits + 4;
|
|
1685
|
+
let size = inputSize;
|
|
1686
|
+
let sig4: number;
|
|
1687
|
+
if (sigSize <= size) {
|
|
1688
|
+
const sigHigh = this.extract(size - 1, size - sigSize + 1, shiftedSig);
|
|
1689
|
+
const sigRest = this.extract(size - sigSize, 0, shiftedSig);
|
|
1690
|
+
sig4 = this.concat(sigHigh, this.bv(OP_BREDOR, sigRest));
|
|
1691
|
+
} else {
|
|
1692
|
+
const extraBits = sigSize - size;
|
|
1693
|
+
const extraZeros = this.num(0, extraBits);
|
|
1694
|
+
sig4 = this.concat(shiftedSig, extraZeros);
|
|
1695
|
+
const lzExt = this.concat(extraZeros, lz);
|
|
1696
|
+
const lzOffset = this.num(extraBits, sigSize);
|
|
1697
|
+
lz = this.bv(OP_BADD, lzExt, lzOffset);
|
|
1698
|
+
size += extraBits;
|
|
1699
|
+
}
|
|
1700
|
+
const sExp = this.bv(OP_BSUB, this.num(size - 2, size), lz);
|
|
1701
|
+
const expSize = ebits + 2;
|
|
1702
|
+
let exp2 = this.extract(expSize - 1, 0, sExp);
|
|
1703
|
+
const expWorstCaseSize = Math.floor(Math.log(size) / Math.log(2) + 1);
|
|
1704
|
+
if (expSize <= expWorstCaseSize) {
|
|
1705
|
+
const maxExp = this.mkMaxExp(expSize);
|
|
1706
|
+
const maxExpBvSize = this.zeroExtend(size - expSize, maxExp);
|
|
1707
|
+
const expTooLarge = this.bv(OP_SLEQ, this.bv(OP_BADD, maxExpBvSize, this.num(1, size)), sExp);
|
|
1708
|
+
const zeroSigSize = this.num(0, sigSize);
|
|
1709
|
+
sig4 = this.mkRawIte(expTooLarge, zeroSigSize, sig4);
|
|
1710
|
+
exp2 = this.mkRawIte(expTooLarge, maxExp, exp2);
|
|
1711
|
+
}
|
|
1712
|
+
const v2 = this.round(sort, rm, sgn, sig4, exp2);
|
|
1713
|
+
return this.mkIte(isZero, pzero, v2);
|
|
1714
|
+
}
|
|
1715
|
+
|
|
1716
|
+
mkToFpSigned(sort: number, rm: number, x: number) {
|
|
1717
|
+
return this.mkToFpBits(sort, rm, x, true);
|
|
1718
|
+
}
|
|
1719
|
+
|
|
1720
|
+
mkToFpUnsigned(sort: number, rm: number, x: number) {
|
|
1721
|
+
return this.mkToFpBits(sort, rm, x, false);
|
|
1722
|
+
}
|
|
1723
|
+
|
|
1724
|
+
protected mkBvUf(decl: number, domain: number[], range: number) {
|
|
1725
|
+
const existing = this.uf2BvUf.get(decl);
|
|
1726
|
+
if (existing !== undefined) return existing;
|
|
1727
|
+
const manager = this.manager;
|
|
1728
|
+
const result = manager.mkFreshFuncDecl(null, domain, range);
|
|
1729
|
+
this.uf2BvUf.set(decl, result);
|
|
1730
|
+
manager.incDeclRef(decl);
|
|
1731
|
+
manager.incDeclRef(result);
|
|
1732
|
+
return result;
|
|
1733
|
+
}
|
|
1734
|
+
|
|
1735
|
+
private joinFp(expr: number) {
|
|
1736
|
+
const [sgn, exp, sig] = this.splitFp(expr);
|
|
1737
|
+
return this.concat(this.concat(sgn, exp), sig);
|
|
1738
|
+
}
|
|
1739
|
+
|
|
1740
|
+
private nanWrap(expr: number) {
|
|
1741
|
+
const argIsNan = this.mkIsNan(expr);
|
|
1742
|
+
const nan = this.mkNan(this.manager.sorts[expr]);
|
|
1743
|
+
const nanBv = this.joinFp(nan);
|
|
1744
|
+
const exprBv = this.joinFp(expr);
|
|
1745
|
+
return this.mkRawIte(argIsNan, nanBv, exprBv);
|
|
1746
|
+
}
|
|
1747
|
+
|
|
1748
|
+
mkToIeeeBv(decl: number, x: number) {
|
|
1749
|
+
const manager = this.manager;
|
|
1750
|
+
const xIsNan = this.mkIsNan(x);
|
|
1751
|
+
const ebits = manager.getEbits(manager.sorts[x]);
|
|
1752
|
+
const sbits = manager.getSbits(manager.sorts[x]);
|
|
1753
|
+
const wrapped = this.nanWrap(x);
|
|
1754
|
+
const range = manager.funcDecls[decl].range;
|
|
1755
|
+
const unspecified = manager.mkApp(
|
|
1756
|
+
this.mkBvUf(decl, [manager.sorts[wrapped]], range),
|
|
1757
|
+
[wrapped],
|
|
1758
|
+
range,
|
|
1759
|
+
);
|
|
1760
|
+
const expBv = this.extract(ebits + sbits - 2, sbits - 1, unspecified);
|
|
1761
|
+
this.extraAssertions.push(manager.mkEq(expBv, this.bv(OP_BNEG, this.num(1, ebits))));
|
|
1762
|
+
const sigBv = this.extract(sbits - 2, 0, unspecified);
|
|
1763
|
+
this.extraAssertions.push(manager.mkNot(manager.mkEq(sigBv, this.num(0, sbits - 1))));
|
|
1764
|
+
const sgnExpSig = this.joinFp(x);
|
|
1765
|
+
return this.simpIte(xIsNan, unspecified, sgnExpSig);
|
|
1766
|
+
}
|
|
1767
|
+
|
|
1768
|
+
mkToBv(decl: number, rmArg: number, x: number, isSigned: boolean) {
|
|
1769
|
+
const manager = this.manager;
|
|
1770
|
+
const rm = manager.getArg(rmArg, 0);
|
|
1771
|
+
const xSort = manager.sorts[x];
|
|
1772
|
+
const range = manager.funcDecls[decl].range;
|
|
1773
|
+
const unpacked = this.unpack(x, true);
|
|
1774
|
+
const ebits = manager.getEbits(xSort);
|
|
1775
|
+
const sbits = manager.getSbits(xSort);
|
|
1776
|
+
const size = manager.funcDecls[decl].parameters[0];
|
|
1777
|
+
const zeroBit = this.num(0, 1);
|
|
1778
|
+
const oneBit = this.num(1, 1);
|
|
1779
|
+
const xIsNan = this.mkIsNan(x);
|
|
1780
|
+
const xIsInf = this.mkIsInf(x);
|
|
1781
|
+
const xIsZero = this.mkIsZero(x);
|
|
1782
|
+
const xIsNeg = this.mkIsNeg(x);
|
|
1783
|
+
this.mkIsNzero(x);
|
|
1784
|
+
const c1 = this.mkOr(xIsNan, xIsInf);
|
|
1785
|
+
const wrapped = this.nanWrap(x);
|
|
1786
|
+
const unspecified = manager.mkApp(
|
|
1787
|
+
this.mkBvUf(decl, [manager.sorts[rm], manager.sorts[wrapped]], range),
|
|
1788
|
+
[rm, wrapped],
|
|
1789
|
+
range,
|
|
1790
|
+
);
|
|
1791
|
+
const v2 = this.num(0, size);
|
|
1792
|
+
const sig =
|
|
1793
|
+
sbits < size + 3 ? this.concat(unpacked.sig, this.num(0, size - sbits + 3)) : unpacked.sig;
|
|
1794
|
+
const sigSize = this.getBvSize(sig);
|
|
1795
|
+
const expExt = this.signExtend(2, unpacked.exp);
|
|
1796
|
+
const lzExt = this.zeroExtend(2, unpacked.lz);
|
|
1797
|
+
const expMLz = this.bv(OP_BSUB, expExt, lzExt);
|
|
1798
|
+
const bigSig = this.concat(this.zeroExtend(size + 2, sig), zeroBit);
|
|
1799
|
+
const bigSigSize = sigSize + 1 + size + 2;
|
|
1800
|
+
const isNegShift = this.bv(OP_SLEQ, expMLz, this.num(0, ebits + 2));
|
|
1801
|
+
let shift = this.mkRawIte(isNegShift, this.bv(OP_BNEG, expMLz), expMLz);
|
|
1802
|
+
if (ebits + 2 < bigSigSize) shift = this.zeroExtend(bigSigSize - ebits - 2, shift);
|
|
1803
|
+
else if (ebits + 2 > bigSigSize) {
|
|
1804
|
+
const upper = this.extract(ebits + 1, bigSigSize, shift);
|
|
1805
|
+
const lower = this.extract(bigSigSize - 1, 0, shift);
|
|
1806
|
+
const upperIsZero = manager.mkEq(upper, this.num(0, this.getBvSize(upper)));
|
|
1807
|
+
const maxShift = this.num(bigSigSize - 1, bigSigSize);
|
|
1808
|
+
shift = this.mkRawIte(upperIsZero, lower, maxShift);
|
|
1809
|
+
}
|
|
1810
|
+
const shiftLimit = this.num(size + 2, this.getBvSize(shift));
|
|
1811
|
+
shift = this.mkRawIte(this.bv(OP_ULEQ, shift, shiftLimit), shift, shiftLimit);
|
|
1812
|
+
const shiftedRight = this.bv(OP_BLSHR, bigSig, shift);
|
|
1813
|
+
const shiftedLeft = this.bv(OP_BSHL, bigSig, shift);
|
|
1814
|
+
const bigSigShifted = this.mkRawIte(isNegShift, shiftedRight, shiftedLeft);
|
|
1815
|
+
const intPart = this.extract(bigSigSize - 1, bigSigSize - (size + 3), bigSigShifted);
|
|
1816
|
+
const last = this.extract(bigSigSize - (size + 3), bigSigSize - (size + 3), bigSigShifted);
|
|
1817
|
+
const round = this.extract(bigSigSize - (size + 4), bigSigSize - (size + 4), bigSigShifted);
|
|
1818
|
+
const stickies = this.extract(bigSigSize - (size + 5), 0, bigSigShifted);
|
|
1819
|
+
const sticky = this.bv(OP_BREDOR, stickies);
|
|
1820
|
+
const roundingDecision = this.mkRoundingDecision(rm, unpacked.sgn, last, round, sticky);
|
|
1821
|
+
const inc = this.zeroExtend(size + 2, roundingDecision);
|
|
1822
|
+
let preRounded = this.bv(OP_BADD, intPart, inc);
|
|
1823
|
+
const incd = manager.mkEq(roundingDecision, oneBit);
|
|
1824
|
+
const prIsZero = manager.mkEq(preRounded, this.num(0, size + 3));
|
|
1825
|
+
let overflow = this.mkAnd(incd, prIsZero);
|
|
1826
|
+
let inRange: number;
|
|
1827
|
+
if (!isSigned) {
|
|
1828
|
+
const upperLimit = this.zeroExtend(3, this.bv(OP_BNEG, this.num(1, size)));
|
|
1829
|
+
const signInRange = this.mkOr(
|
|
1830
|
+
manager.mkNot(xIsNeg),
|
|
1831
|
+
manager.mkEq(preRounded, this.num(0, size + 3)),
|
|
1832
|
+
);
|
|
1833
|
+
const noOverflow = manager.mkNot(overflow);
|
|
1834
|
+
const magnitudeInRange = this.bv(OP_ULEQ, preRounded, upperLimit);
|
|
1835
|
+
inRange = this.mkAnd(signInRange, noOverflow, magnitudeInRange);
|
|
1836
|
+
} else {
|
|
1837
|
+
const lowerBase = size > 1 ? this.concat(oneBit, this.num(0, size - 1)) : oneBit;
|
|
1838
|
+
const lowerLimit = this.signExtend(3, lowerBase);
|
|
1839
|
+
const upperLimit =
|
|
1840
|
+
size > 1 ? this.zeroExtend(4, this.bv(OP_BNEG, this.num(1, size - 1))) : this.num(0, 4);
|
|
1841
|
+
overflow = this.mkOr(
|
|
1842
|
+
overflow,
|
|
1843
|
+
this.bv(OP_SLEQ, preRounded, this.bv(OP_BNEG, this.num(1, size + 3))),
|
|
1844
|
+
);
|
|
1845
|
+
preRounded = this.mkRawIte(xIsNeg, this.bv(OP_BNEG, preRounded), preRounded);
|
|
1846
|
+
const noOverflow = manager.mkNot(overflow);
|
|
1847
|
+
const aboveLower = this.bv(OP_SLEQ, lowerLimit, preRounded);
|
|
1848
|
+
const belowUpper = this.bv(OP_SLEQ, preRounded, upperLimit);
|
|
1849
|
+
inRange = this.mkAnd(noOverflow, aboveLower, belowUpper);
|
|
1850
|
+
}
|
|
1851
|
+
const rounded = this.extract(size - 1, 0, preRounded);
|
|
1852
|
+
const result = this.mkRawIte(manager.mkNot(inRange), unspecified, rounded);
|
|
1853
|
+
const withZero = this.mkRawIte(xIsZero, v2, result);
|
|
1854
|
+
return this.mkRawIte(c1, unspecified, withZero);
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
mkIsNan(expr: number) {
|
|
1858
|
+
const [, exp, sig] = this.splitFp(expr);
|
|
1859
|
+
const topExp = this.mkTopExp(this.getBvSize(exp));
|
|
1860
|
+
const zero = this.num(0, this.getBvSize(sig));
|
|
1861
|
+
const sigIsZero = this.simpEq(sig, zero);
|
|
1862
|
+
const sigIsNotZero = this.simpNot(sigIsZero);
|
|
1863
|
+
const expIsTop = this.simpEq(exp, topExp);
|
|
1864
|
+
return this.simpAnd(expIsTop, sigIsNotZero);
|
|
1865
|
+
}
|
|
1866
|
+
|
|
1867
|
+
mkIsInf(expr: number) {
|
|
1868
|
+
const [, exp, sig] = this.splitFp(expr);
|
|
1869
|
+
const topExp = this.mkTopExp(this.getBvSize(exp));
|
|
1870
|
+
const zero = this.num(0, this.getBvSize(sig));
|
|
1871
|
+
const eq1 = this.simpEq(sig, zero);
|
|
1872
|
+
const eq2 = this.simpEq(exp, topExp);
|
|
1873
|
+
return this.simpAnd(eq1, eq2);
|
|
1874
|
+
}
|
|
1875
|
+
|
|
1876
|
+
private mkIsPinf(expr: number) {
|
|
1877
|
+
const isPos = this.mkIsPos(expr);
|
|
1878
|
+
const isInf = this.mkIsInf(expr);
|
|
1879
|
+
return this.simpAnd(isPos, isInf);
|
|
1880
|
+
}
|
|
1881
|
+
|
|
1882
|
+
private mkIsNinf(expr: number) {
|
|
1883
|
+
const isNeg = this.mkIsNeg(expr);
|
|
1884
|
+
const isInf = this.mkIsInf(expr);
|
|
1885
|
+
return this.simpAnd(isNeg, isInf);
|
|
1886
|
+
}
|
|
1887
|
+
|
|
1888
|
+
private mkIsPos(expr: number) {
|
|
1889
|
+
const sgn = this.manager.getArg(expr, 0);
|
|
1890
|
+
return this.simpEq(sgn, this.num(0, this.getBvSize(sgn)));
|
|
1891
|
+
}
|
|
1892
|
+
|
|
1893
|
+
private mkIsNeg(expr: number) {
|
|
1894
|
+
const sgn = this.manager.getArg(expr, 0);
|
|
1895
|
+
return this.simpEq(sgn, this.num(1, this.getBvSize(sgn)));
|
|
1896
|
+
}
|
|
1897
|
+
|
|
1898
|
+
mkIsZero(expr: number) {
|
|
1899
|
+
const [, exp, sig] = this.splitFp(expr);
|
|
1900
|
+
const botExp = this.mkBotExp(this.getBvSize(exp));
|
|
1901
|
+
const zero = this.num(0, this.getBvSize(sig));
|
|
1902
|
+
const eq1 = this.simpEq(sig, zero);
|
|
1903
|
+
const eq2 = this.simpEq(exp, botExp);
|
|
1904
|
+
return this.simpAnd(eq1, eq2);
|
|
1905
|
+
}
|
|
1906
|
+
|
|
1907
|
+
private mkIsNzero(expr: number) {
|
|
1908
|
+
const [sgn] = this.splitFp(expr);
|
|
1909
|
+
const isZero = this.mkIsZero(expr);
|
|
1910
|
+
const eq = this.simpEq(sgn, this.num(1, 1));
|
|
1911
|
+
return this.simpAnd(eq, isZero);
|
|
1912
|
+
}
|
|
1913
|
+
|
|
1914
|
+
private mkIsPzero(expr: number) {
|
|
1915
|
+
const [sgn] = this.splitFp(expr);
|
|
1916
|
+
const isZero = this.mkIsZero(expr);
|
|
1917
|
+
const eq = this.simpEq(sgn, this.num(0, 1));
|
|
1918
|
+
return this.simpAnd(eq, isZero);
|
|
1919
|
+
}
|
|
1920
|
+
|
|
1921
|
+
mkIsDenormal(expr: number) {
|
|
1922
|
+
const [, exp] = this.splitFp(expr);
|
|
1923
|
+
const zero = this.num(0, this.getBvSize(exp));
|
|
1924
|
+
const zexp = this.simpEq(exp, zero);
|
|
1925
|
+
const isZero = this.mkIsZero(expr);
|
|
1926
|
+
const nIsZero = this.simpNot(isZero);
|
|
1927
|
+
return this.simpAnd(nIsZero, zexp);
|
|
1928
|
+
}
|
|
1929
|
+
|
|
1930
|
+
mkIsNormal(expr: number) {
|
|
1931
|
+
const [, exp] = this.splitFp(expr);
|
|
1932
|
+
const isDenormal = this.mkIsDenormal(expr);
|
|
1933
|
+
const isZero = this.mkIsZero(expr);
|
|
1934
|
+
const ebits = this.getBvSize(exp);
|
|
1935
|
+
const isSpecial = this.simpEq(exp, this.num(getPowerOfTwoMinusOne(ebits), ebits));
|
|
1936
|
+
const specialOrDenormal = this.simpOr(isSpecial, isDenormal);
|
|
1937
|
+
return this.simpNot(this.simpOr(isZero, specialOrDenormal));
|
|
1938
|
+
}
|
|
1939
|
+
|
|
1940
|
+
private mkIsRm(rm: number, value: number) {
|
|
1941
|
+
return this.simpEq(rm, this.num(value, 3));
|
|
1942
|
+
}
|
|
1943
|
+
|
|
1944
|
+
private mkTopExp(size: number) {
|
|
1945
|
+
return this.num(getPowerOfTwoMinusOne(size), size);
|
|
1946
|
+
}
|
|
1947
|
+
|
|
1948
|
+
private mkBotExp(size: number) {
|
|
1949
|
+
return this.num(0, size);
|
|
1950
|
+
}
|
|
1951
|
+
|
|
1952
|
+
private mkMinExp(ebits: number) {
|
|
1953
|
+
return this.num(-getPowerOfTwoMinusOne(ebits - 1) + 1n, ebits);
|
|
1954
|
+
}
|
|
1955
|
+
|
|
1956
|
+
private mkMaxExp(ebits: number) {
|
|
1957
|
+
return this.num(getPowerOfTwoMinusOne(ebits - 1), ebits);
|
|
1958
|
+
}
|
|
1959
|
+
|
|
1960
|
+
private mkLeadingZeros(expr: number, maxBits: number): number {
|
|
1961
|
+
const size = this.getBvSize(expr);
|
|
1962
|
+
if (size === 0) return this.num(0, maxBits);
|
|
1963
|
+
if (size === 1) {
|
|
1964
|
+
const nilBit = this.num(0, 1);
|
|
1965
|
+
const oneM = this.num(1, maxBits);
|
|
1966
|
+
const nilM = this.num(0, maxBits);
|
|
1967
|
+
const eq = this.simpEq(expr, nilBit);
|
|
1968
|
+
return this.simpIte(eq, oneM, nilM);
|
|
1969
|
+
}
|
|
1970
|
+
const high = this.extract(size - 1, Math.floor(size / 2), expr);
|
|
1971
|
+
const low = this.extract(Math.floor(size / 2) - 1, 0, expr);
|
|
1972
|
+
const highSize = this.getBvSize(high);
|
|
1973
|
+
const lzHigh = this.mkLeadingZeros(high, maxBits);
|
|
1974
|
+
const lzLow = this.mkLeadingZeros(low, maxBits);
|
|
1975
|
+
const nilH = this.num(0, highSize);
|
|
1976
|
+
const highIsZero = this.simpEq(high, nilH);
|
|
1977
|
+
const hM = this.num(highSize, maxBits);
|
|
1978
|
+
const sum = this.bv(OP_BADD, hM, lzLow);
|
|
1979
|
+
return this.simpIte(highIsZero, sum, lzHigh);
|
|
1980
|
+
}
|
|
1981
|
+
|
|
1982
|
+
private mkBias(expr: number) {
|
|
1983
|
+
const ebits = this.getBvSize(expr);
|
|
1984
|
+
const bias = this.num(getPowerOfTwoMinusOne(ebits - 1), ebits);
|
|
1985
|
+
return this.bv(OP_BADD, expr, bias);
|
|
1986
|
+
}
|
|
1987
|
+
|
|
1988
|
+
private mkUnbias(expr: number) {
|
|
1989
|
+
const ebits = this.getBvSize(expr);
|
|
1990
|
+
const plusOne = this.bv(OP_BADD, expr, this.num(1, ebits));
|
|
1991
|
+
const leading = this.extract(ebits - 1, ebits - 1, plusOne);
|
|
1992
|
+
const notLeading = this.bv(OP_BNOT, leading);
|
|
1993
|
+
const rest = this.extract(ebits - 2, 0, plusOne);
|
|
1994
|
+
return this.concat(notLeading, rest);
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
private unpack(expr: number, isNormalizing: boolean): Unpacked {
|
|
1998
|
+
const manager = this.manager;
|
|
1999
|
+
const sort = manager.sorts[expr];
|
|
2000
|
+
const sbits = manager.getSbits(sort);
|
|
2001
|
+
const ebits = manager.getEbits(sort);
|
|
2002
|
+
const [sgn, exp, sig] = this.splitFp(expr);
|
|
2003
|
+
const isNormal = this.mkIsNormal(expr);
|
|
2004
|
+
const normalSig = this.concat(this.num(1, 1), sig);
|
|
2005
|
+
const normalExp = this.mkUnbias(exp);
|
|
2006
|
+
let denormalSig = this.zeroExtend(1, sig);
|
|
2007
|
+
const denormalExp = this.mkUnbias(this.num(1, ebits));
|
|
2008
|
+
const zeroE = this.num(0, ebits);
|
|
2009
|
+
let lz = zeroE;
|
|
2010
|
+
if (isNormalizing) {
|
|
2011
|
+
const zeroS = this.num(0, sbits);
|
|
2012
|
+
const isSigZero = this.simpEq(zeroS, denormalSig);
|
|
2013
|
+
const lzD = this.mkLeadingZeros(denormalSig, ebits);
|
|
2014
|
+
const normOrZero = this.mkOr(isNormal, isSigZero);
|
|
2015
|
+
lz = this.simpIte(normOrZero, zeroE, lzD);
|
|
2016
|
+
const shift = this.simpIte(isSigZero, zeroE, lz);
|
|
2017
|
+
if (ebits <= sbits) {
|
|
2018
|
+
const extended = this.zeroExtend(sbits - ebits, shift);
|
|
2019
|
+
denormalSig = this.bv(OP_BSHL, denormalSig, extended);
|
|
2020
|
+
} else {
|
|
2021
|
+
const zeroEms = this.num(0, ebits - sbits);
|
|
2022
|
+
const sbitsS = this.num(sbits, sbits);
|
|
2023
|
+
const high = this.extract(ebits - 1, sbits, shift);
|
|
2024
|
+
const isShiftZero = this.simpEq(zeroEms, high);
|
|
2025
|
+
const shortShift = this.extract(sbits - 1, 0, shift);
|
|
2026
|
+
const shiftAmount = this.simpIte(isShiftZero, shortShift, sbitsS);
|
|
2027
|
+
denormalSig = this.bv(OP_BSHL, denormalSig, shiftAmount);
|
|
2028
|
+
}
|
|
2029
|
+
}
|
|
2030
|
+
return {
|
|
2031
|
+
sgn,
|
|
2032
|
+
sig: this.simpIte(isNormal, normalSig, denormalSig),
|
|
2033
|
+
exp: this.simpIte(isNormal, normalExp, denormalExp),
|
|
2034
|
+
lz,
|
|
2035
|
+
};
|
|
2036
|
+
}
|
|
2037
|
+
|
|
2038
|
+
private mkRoundingDecision(rm: number, sgn: number, last: number, round: number, sticky: number) {
|
|
2039
|
+
const lastOrSticky = this.bv(OP_BOR, last, sticky);
|
|
2040
|
+
const roundOrSticky = this.bv(OP_BOR, round, sticky);
|
|
2041
|
+
this.bv(OP_BNOT, last);
|
|
2042
|
+
const notRound = this.bv(OP_BNOT, round);
|
|
2043
|
+
this.bv(OP_BNOT, sticky);
|
|
2044
|
+
const notLors = this.bv(OP_BNOT, lastOrSticky);
|
|
2045
|
+
const notRors = this.bv(OP_BNOT, roundOrSticky);
|
|
2046
|
+
const notSgn = this.bv(OP_BNOT, sgn);
|
|
2047
|
+
const incTeven = this.bv(OP_BNOT, this.bv(OP_BOR, notRound, notLors));
|
|
2048
|
+
const incPos = this.bv(OP_BNOT, this.bv(OP_BOR, sgn, notRors));
|
|
2049
|
+
const incNeg = this.bv(OP_BNOT, this.bv(OP_BOR, notSgn, notRors));
|
|
2050
|
+
const nilBit = this.num(0, 1);
|
|
2051
|
+
const rmIsToNeg = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
2052
|
+
const rmIsToPos = this.mkIsRm(rm, BV_RM_TO_POSITIVE);
|
|
2053
|
+
const rmIsAway = this.mkIsRm(rm, BV_RM_TIES_TO_AWAY);
|
|
2054
|
+
const rmIsEven = this.mkIsRm(rm, BV_RM_TIES_TO_EVEN);
|
|
2055
|
+
const incC4 = this.simpIte(rmIsToNeg, incNeg, nilBit);
|
|
2056
|
+
const incC3 = this.simpIte(rmIsToPos, incPos, incC4);
|
|
2057
|
+
const incC2 = this.simpIte(rmIsAway, round, incC3);
|
|
2058
|
+
return this.simpIte(rmIsEven, incTeven, incC2);
|
|
2059
|
+
}
|
|
2060
|
+
|
|
2061
|
+
round(sort: number, rm: number, sgn: number, inputSig: number, inputExp: number) {
|
|
2062
|
+
const manager = this.manager;
|
|
2063
|
+
const ebits = manager.getEbits(sort);
|
|
2064
|
+
const sbits = manager.getSbits(sort);
|
|
2065
|
+
const eMin = this.mkMinExp(ebits);
|
|
2066
|
+
const eMax = this.mkMaxExp(ebits);
|
|
2067
|
+
const oneBit = this.num(1, 1);
|
|
2068
|
+
const hExp = this.extract(ebits + 1, ebits + 1, inputExp);
|
|
2069
|
+
const shExp = this.extract(ebits, ebits, inputExp);
|
|
2070
|
+
const thExp = this.extract(ebits - 1, ebits - 1, inputExp);
|
|
2071
|
+
const e3 = this.simpEq(hExp, oneBit);
|
|
2072
|
+
const e2 = this.simpEq(shExp, oneBit);
|
|
2073
|
+
const e1 = this.simpEq(thExp, oneBit);
|
|
2074
|
+
const e21 = this.simpOr(e2, e1);
|
|
2075
|
+
const ne3 = this.simpNot(e3);
|
|
2076
|
+
const eTopThree = this.simpAnd(ne3, e21);
|
|
2077
|
+
const extEmax = this.zeroExtend(2, eMax);
|
|
2078
|
+
const topSig = this.extract(sbits + 3, sbits + 3, inputSig);
|
|
2079
|
+
const eEqEmax = this.simpEq(extEmax, inputExp);
|
|
2080
|
+
const sigm1 = this.simpEq(topSig, oneBit);
|
|
2081
|
+
const eEqEmaxAndSigm1 = this.simpAnd(eEqEmax, sigm1);
|
|
2082
|
+
const ovf1 = this.simpOr(eTopThree, eEqEmaxAndSigm1);
|
|
2083
|
+
const lz = this.mkLeadingZeros(inputSig, ebits + 2);
|
|
2084
|
+
const t1 = this.bv(OP_BADD, inputExp, this.num(1, ebits + 2));
|
|
2085
|
+
const t2 = this.bv(OP_BSUB, t1, lz);
|
|
2086
|
+
const t = this.bv(OP_BSUB, t2, this.signExtend(2, eMin));
|
|
2087
|
+
const tiny = this.bv(OP_SLEQ, t, this.num(-1, ebits + 2));
|
|
2088
|
+
const beta = this.bv(OP_BADD, this.bv(OP_BSUB, inputExp, lz), this.num(1, ebits + 2));
|
|
2089
|
+
const sigmaSub = this.bv(OP_BSUB, inputExp, this.signExtend(2, eMin));
|
|
2090
|
+
const sigmaAdd = this.bv(OP_BADD, sigmaSub, this.num(1, ebits + 2));
|
|
2091
|
+
const sigma = this.simpIte(tiny, sigmaAdd, lz);
|
|
2092
|
+
const sigSize = this.getBvSize(inputSig);
|
|
2093
|
+
const sigmaSize = ebits + 2;
|
|
2094
|
+
const sigmaNeg = this.bv(OP_BNEG, sigma);
|
|
2095
|
+
let sigmaNegCapped = sigmaNeg;
|
|
2096
|
+
if (getLog2(sbits + 2) < sigmaSize) {
|
|
2097
|
+
const sigmaCap = this.num(sbits + 2, sigmaSize);
|
|
2098
|
+
const sigmaLeCap = this.bv(OP_ULEQ, sigmaNeg, sigmaCap);
|
|
2099
|
+
sigmaNegCapped = this.simpIte(sigmaLeCap, sigmaNeg, sigmaCap);
|
|
2100
|
+
}
|
|
2101
|
+
const sigmaLtZero = this.bv(OP_SLEQ, sigma, this.num(-1, sigmaSize));
|
|
2102
|
+
const sigExt = this.concat(inputSig, this.num(0, sigSize));
|
|
2103
|
+
const shiftWidth = 2 * sigSize;
|
|
2104
|
+
const rsShift =
|
|
2105
|
+
sigmaSize <= shiftWidth
|
|
2106
|
+
? this.zeroExtend(shiftWidth - sigmaSize, sigmaNegCapped)
|
|
2107
|
+
: this.extract(shiftWidth - 1, 0, sigmaNegCapped);
|
|
2108
|
+
const lsShift =
|
|
2109
|
+
sigmaSize <= shiftWidth
|
|
2110
|
+
? this.zeroExtend(shiftWidth - sigmaSize, sigma)
|
|
2111
|
+
: this.extract(shiftWidth - 1, 0, sigma);
|
|
2112
|
+
const rsSig = this.bv(OP_BLSHR, sigExt, rsShift);
|
|
2113
|
+
const lsSig = this.bv(OP_BSHL, sigExt, lsShift);
|
|
2114
|
+
const bigShSig = this.simpIte(sigmaLtZero, rsSig, lsSig);
|
|
2115
|
+
const sigExtractLowBit = 2 * sigSize - 1 - (sbits + 2) + 1;
|
|
2116
|
+
const shiftedSig = this.extract(2 * sigSize - 1, sigExtractLowBit, bigShSig);
|
|
2117
|
+
const stickyBit = this.bv(OP_BREDOR, this.extract(sigExtractLowBit - 1, 0, bigShSig));
|
|
2118
|
+
const extSticky = this.zeroExtend(sbits + 1, stickyBit);
|
|
2119
|
+
const stickySig = this.bv(OP_BOR, shiftedSig, extSticky);
|
|
2120
|
+
const extEmin = this.zeroExtend(2, eMin);
|
|
2121
|
+
const tinyExp = this.simpIte(tiny, extEmin, beta);
|
|
2122
|
+
const sticky = this.extract(0, 0, stickySig);
|
|
2123
|
+
const round = this.extract(1, 1, stickySig);
|
|
2124
|
+
const last = this.extract(2, 2, stickySig);
|
|
2125
|
+
const retainedSig = this.extract(sbits + 1, 2, stickySig);
|
|
2126
|
+
const incBit = this.mkRoundingDecision(rm, sgn, last, round, sticky);
|
|
2127
|
+
const sigWide = this.zeroExtend(1, retainedSig);
|
|
2128
|
+
const inc = this.zeroExtend(sbits, incBit);
|
|
2129
|
+
const incrementedSig = this.bv(OP_BADD, sigWide, inc);
|
|
2130
|
+
const sigTop = this.extract(sbits, sbits, incrementedSig);
|
|
2131
|
+
const sigOvf = this.simpEq(sigTop, oneBit);
|
|
2132
|
+
const hallbut1Sig = this.extract(sbits, 1, incrementedSig);
|
|
2133
|
+
const lallbut1Sig = this.extract(sbits - 1, 0, incrementedSig);
|
|
2134
|
+
const normalizedSig = this.simpIte(sigOvf, hallbut1Sig, lallbut1Sig);
|
|
2135
|
+
const expP1 = this.bv(OP_BADD, tinyExp, this.num(1, ebits + 2));
|
|
2136
|
+
const normalizedExp = this.simpIte(sigOvf, expP1, tinyExp);
|
|
2137
|
+
const unadjustedBiasedExp = this.mkBias(this.extract(ebits - 1, 0, normalizedExp));
|
|
2138
|
+
const expRedand = this.bv(OP_BREDAND, unadjustedBiasedExp);
|
|
2139
|
+
const preOvf2 = this.simpEq(expRedand, oneBit);
|
|
2140
|
+
const ovf2 = this.simpAnd(sigOvf, preOvf2);
|
|
2141
|
+
const pem2m1 = this.num(getPowerOfTwoMinusOne(ebits - 2), ebits);
|
|
2142
|
+
const biasedExp = this.simpIte(ovf2, pem2m1, unadjustedBiasedExp);
|
|
2143
|
+
const ovf = this.simpOr(ovf1, ovf2);
|
|
2144
|
+
const topExp = this.mkTopExp(ebits);
|
|
2145
|
+
const botExp = this.mkBotExp(ebits);
|
|
2146
|
+
const nilBit = this.num(0, 1);
|
|
2147
|
+
const rmIsToZero = this.mkIsRm(rm, BV_RM_TO_ZERO);
|
|
2148
|
+
const rmIsToNeg = this.mkIsRm(rm, BV_RM_TO_NEGATIVE);
|
|
2149
|
+
const rmIsToPos = this.mkIsRm(rm, BV_RM_TO_POSITIVE);
|
|
2150
|
+
const rmZeroOrNeg = this.simpOr(rmIsToZero, rmIsToNeg);
|
|
2151
|
+
const rmZeroOrPos = this.simpOr(rmIsToZero, rmIsToPos);
|
|
2152
|
+
const zeroBit = this.num(0, 1);
|
|
2153
|
+
const sgnIsZero = this.simpEq(sgn, zeroBit);
|
|
2154
|
+
const maxSig = this.num(getPowerOfTwoMinusOne(sbits - 1), sbits - 1);
|
|
2155
|
+
const maxExp = this.concat(
|
|
2156
|
+
this.num(getPowerOfTwoMinusOne(ebits - 1), ebits - 1),
|
|
2157
|
+
this.num(0, 1),
|
|
2158
|
+
);
|
|
2159
|
+
const infSig = this.num(0, sbits - 1);
|
|
2160
|
+
const maxInfExpNeg = this.simpIte(rmZeroOrPos, maxExp, topExp);
|
|
2161
|
+
const maxInfExpPos = this.simpIte(rmZeroOrNeg, maxExp, topExp);
|
|
2162
|
+
const ovflExp = this.simpIte(sgnIsZero, maxInfExpPos, maxInfExpNeg);
|
|
2163
|
+
const denormalBit = this.extract(sbits - 1, sbits - 1, normalizedSig);
|
|
2164
|
+
const nDCheck = this.simpEq(denormalBit, nilBit);
|
|
2165
|
+
const nDExp = this.simpIte(nDCheck, botExp, biasedExp);
|
|
2166
|
+
const resExp = this.simpIte(ovf, ovflExp, nDExp);
|
|
2167
|
+
const maxInfSigNeg = this.simpIte(rmZeroOrPos, maxSig, infSig);
|
|
2168
|
+
const maxInfSigPos = this.simpIte(rmZeroOrNeg, maxSig, infSig);
|
|
2169
|
+
const ovflSig = this.simpIte(sgnIsZero, maxInfSigPos, maxInfSigNeg);
|
|
2170
|
+
const restSig = this.extract(sbits - 2, 0, normalizedSig);
|
|
2171
|
+
const resSig = this.simpIte(ovf, ovflSig, restSig);
|
|
2172
|
+
return this.mkFp(sgn, resExp, resSig);
|
|
2173
|
+
}
|
|
2174
|
+
}
|
|
2175
|
+
|
|
2176
|
+
export class WrappedFpa2BvConverter extends Fpa2BvConverter {
|
|
2177
|
+
constructor(
|
|
2178
|
+
manager: AstManager,
|
|
2179
|
+
simp: Rewriter,
|
|
2180
|
+
private wrapRewriter: Rewriter,
|
|
2181
|
+
) {
|
|
2182
|
+
super(manager, simp);
|
|
2183
|
+
}
|
|
2184
|
+
|
|
2185
|
+
wrap(expr: number) {
|
|
2186
|
+
const manager = this.manager;
|
|
2187
|
+
if (this.isFp(expr)) {
|
|
2188
|
+
const concatenation = this.concat(...this.splitFp(expr));
|
|
2189
|
+
const rewritten = this.wrapRewriter.rewrite(concatenation);
|
|
2190
|
+
manager.releaseLater(rewritten);
|
|
2191
|
+
return rewritten;
|
|
2192
|
+
}
|
|
2193
|
+
return mkFpaApp(manager, OP_FPA_BVWRAP, [expr]);
|
|
2194
|
+
}
|
|
2195
|
+
|
|
2196
|
+
unwrap(expr: number, sort: number) {
|
|
2197
|
+
const manager = this.manager;
|
|
2198
|
+
if (manager.isRmSort(sort)) {
|
|
2199
|
+
const isRna = manager.mkEq(expr, this.num(BV_RM_TIES_TO_AWAY, 3));
|
|
2200
|
+
const rna = mkRmNumeral(manager, BV_RM_TIES_TO_AWAY);
|
|
2201
|
+
const isRne = manager.mkEq(expr, this.num(BV_RM_TIES_TO_EVEN, 3));
|
|
2202
|
+
const rne = mkRmNumeral(manager, BV_RM_TIES_TO_EVEN);
|
|
2203
|
+
const isRtn = manager.mkEq(expr, this.num(BV_RM_TO_NEGATIVE, 3));
|
|
2204
|
+
const rtn = mkRmNumeral(manager, BV_RM_TO_NEGATIVE);
|
|
2205
|
+
const isRtp = manager.mkEq(expr, this.num(BV_RM_TO_POSITIVE, 3));
|
|
2206
|
+
const rtp = mkRmNumeral(manager, BV_RM_TO_POSITIVE);
|
|
2207
|
+
const rtz = mkRmNumeral(manager, BV_RM_TO_ZERO);
|
|
2208
|
+
const withRtp = this.mkRawIte(isRtp, rtp, rtz);
|
|
2209
|
+
const withRtn = this.mkRawIte(isRtn, rtn, withRtp);
|
|
2210
|
+
const withRne = this.mkRawIte(isRne, rne, withRtn);
|
|
2211
|
+
return this.mkRawIte(isRna, rna, withRne);
|
|
2212
|
+
}
|
|
2213
|
+
const size = this.getBvSize(expr);
|
|
2214
|
+
const sbits = manager.getSbits(sort);
|
|
2215
|
+
const sgn = this.extract(size - 1, size - 1, expr);
|
|
2216
|
+
const exp = this.extract(size - 2, sbits - 1, expr);
|
|
2217
|
+
const sig = this.extract(sbits - 2, 0, expr);
|
|
2218
|
+
return this.mkFp(sgn, exp, sig);
|
|
2219
|
+
}
|
|
2220
|
+
|
|
2221
|
+
override mkConst(decl: number) {
|
|
2222
|
+
const existing = this.constants.get(decl);
|
|
2223
|
+
if (existing !== undefined) return existing;
|
|
2224
|
+
const manager = this.manager;
|
|
2225
|
+
const sort = manager.funcDecls[decl].range;
|
|
2226
|
+
const bv = this.wrap(manager.mkApp(decl, [], sort));
|
|
2227
|
+
const size = this.getBvSize(bv);
|
|
2228
|
+
const sbits = manager.getSbits(sort);
|
|
2229
|
+
const sgn = this.extract(size - 1, size - 1, bv);
|
|
2230
|
+
const exp = this.extract(size - 2, sbits - 1, bv);
|
|
2231
|
+
const sig = this.extract(sbits - 2, 0, bv);
|
|
2232
|
+
return this.cacheConst(this.constants, decl, this.mkFp(sgn, exp, sig));
|
|
2233
|
+
}
|
|
2234
|
+
|
|
2235
|
+
override mkRmConst(decl: number) {
|
|
2236
|
+
const existing = this.rmConstants.get(decl);
|
|
2237
|
+
if (existing !== undefined) return existing;
|
|
2238
|
+
const manager = this.manager;
|
|
2239
|
+
const bv = this.wrap(manager.mkApp(decl, [], manager.funcDecls[decl].range));
|
|
2240
|
+
return this.cacheConst(this.rmConstants, decl, this.mkBv2Rm(bv));
|
|
2241
|
+
}
|
|
2242
|
+
|
|
2243
|
+
override mkUf(decl: number, args: number[]) {
|
|
2244
|
+
const manager = this.manager;
|
|
2245
|
+
const range = manager.funcDecls[decl].range;
|
|
2246
|
+
const result = manager.mkApp(decl, args, range);
|
|
2247
|
+
if (manager.isFpSort(range)) return this.unwrap(this.wrap(result), range);
|
|
2248
|
+
if (manager.isRmSort(range)) return this.mkBv2Rm(this.wrap(result));
|
|
2249
|
+
return result;
|
|
2250
|
+
}
|
|
2251
|
+
}
|