eyeprolog 1.3.27 → 1.3.28

package/conformance-report.md

@@ -18,9 +18,10 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | proofs | 0 | 0 | 0 | 21 | 21 |
 | query | 8 | 2 | 0 | 0 | 10 |
 | rules | 13 | 3 | 0 | 0 | 16 |
+| stc | 5 | 4 | 0 | 0 | 9 |
 | strings | 40 | 0 | 0 | 0 | 40 |
 | syntax | 12 | 23 | 0 | 0 | 35 |
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 7 | 0 | 0 | 23 |
-| **Total** | **484** | **267** | **19** | **21** | **791** |
+| **Total** | **489** | **271** | **19** | **21** | **800** |

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.27",
+  "version": "1.3.28",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/iso.js

@@ -2404,7 +2404,8 @@ function evaluateOperation(term, args) {
   if (name === '/' && y === 0) throw new PrologError('evaluation_error(zero_divisor)');
   let value;
   if (name === 'max' || name === 'min') {
-    const chooseLeft = name === 'max' ? x >= y : x <= y;
+    const cmp = compareArithmeticValues(args[0], args[1]);
+    const chooseLeft = name === 'max' ? cmp >= 0 : cmp <= 0;
     return chooseLeft ? args[0] : args[1];
   }
   if (name === 'atan2') {
@@ -2436,12 +2437,33 @@ function numericTerm(value) {
 export function evaluateArithmetic(term, env) {
   return evaluate(term, env);
 }
+function compareIntegerToFloat(integerValue, floatValue) {
+  if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
+
+  // Do not round an unbounded integer through JavaScript Number before a
+  // mixed arithmetic comparison.  Every integral IEEE-754 double can be
+  // converted back to the exact integer value it represents; fractional
+  // doubles necessarily have magnitude below 2^53, so their truncation is
+  // also exact.  This preserves mathematical ordering across the I/F boundary
+  // (STC #50), e.g. 9007199254740993 > 9007199254740992.0.
+  if (Number.isInteger(floatValue)) {
+    const floatInteger = BigInt(floatValue);
+    return integerValue < floatInteger ? -1 : integerValue > floatInteger ? 1 : 0;
+  }
+
+  const truncated = BigInt(Math.trunc(floatValue));
+  if (integerValue < truncated) return -1;
+  if (integerValue > truncated) return 1;
+  return floatValue > 0 ? -1 : 1;
+}
+
 export function compareArithmeticValues(left, right) {
   const a = left.value;
   const b = right.value;
-  return left.integer && right.integer
-    ? (a < b ? -1 : a > b ? 1 : 0)
-    : (Number(a) < Number(b) ? -1 : Number(a) > Number(b) ? 1 : 0);
+  if (left.integer && right.integer) return a < b ? -1 : a > b ? 1 : 0;
+  if (left.integer) return compareIntegerToFloat(a, b);
+  if (right.integer) return -compareIntegerToFloat(b, a);
+  return a < b ? -1 : a > b ? 1 : 0;
 }
 function* isBuiltin({ goal, env }) {
   const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));

package/test/conformance/README.md

@@ -11,6 +11,9 @@ and proof output test the behavior of the JavaScript implementation.
 corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
 executable cases. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
+[STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
+implementation questions from the post-N289 working draft; those cases are
+review evidence, not normative ISO claims.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
@@ -131,8 +134,9 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 386 cases in `iso/` and 791 file-based conformance cases in
-total. The separate strict-reader WG17 matrix has 366 executable dispositions.
+The corpus has 386 cases in `iso/` and 800 file-based conformance cases in
+total. Of those, 9 cases in `stc/` are explicitly labelled working-draft
+review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
 The generated `conformance-report.md` is the authoritative source for current
 category totals. Together with regression, documentation-sync, API, example,
 and book-example checks, `npm test` is the release gate.

package/test/conformance/STC-DRAFT-STATUS.md

@@ -0,0 +1,62 @@
+# WG17 STC draft review status
+
+Source: [post-N289 draft for further technical corrigenda](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc)
+
+This file tracks implementation-relevant questions from the WG17 **working
+draft**. It is deliberately separate from the ISO/IEC 13211-1 conformance
+claim: an STC item is a proposal or defect report until WG17 adopts normative
+wording.
+
+The purpose of this ledger is practical. Where an STC item can be expressed as
+an executable Prolog observation, EyeProlog keeps a standards-facing case under
+`test/conformance/stc/` (or points to an existing strict/WG17 case) so discussion
+of the draft can expose implementation problems before they become release
+regressions.
+
+## Reviewed executable items
+
+| STC item | Topic | EyeProlog evidence / finding |
+| --- | --- | --- |
+| [#37](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#37) | `clause/2` variable identity | `stc/clause_variable_identity` verifies sharing between head and body is preserved. |
+| [#39](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#39) | negative-number syntax | Covered extensively by the upstream-first WG17 syntax matrix; unary-minus read-back discrepancies found by that matrix were fixed in v1.3.27. |
+| [#40](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#40) | inexact float representation | EyeProlog uses the host IEEE-754 binary64 value and requires written floats to read back to that same value. Input underflow is covered by `stc/float_underflow_input`. |
+| [#42](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42) | integer-to-float conversion for float functions | `stc/integer_to_float_evaluable` verifies an integer expression is accepted by `sin/1` and produces a float. |
+| [#44](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#44) | `char_code/2` error classification | Existing strict conformance cases require `representation_error(character_code)` for an integer outside the character-code set. |
+| [#49](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#49) | `read_term/3` and EOF | Covered by strict reader/conformance tests and the interactive-read regressions. |
+| [#50](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50) | mixed integer/float arithmetic comparison | **Found a bug during this audit.** EyeProlog rounded unbounded integers through JavaScript `Number`; `9007199254740993 > 9007199254740992.0` incorrectly failed. `stc/mixed_integer_float_comparison` now requires exact cross-type ordering and `max/2`/`min/2` use the same comparison. |
+| [#55](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#55) | integer rounding function | Existing flag conformance verifies `integer_rounding_function = toward_zero`. |
+| [#58](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#58) | `set_prolog_flag/2` instantiation error | Existing strict/error coverage requires an instantiation error when a required flag value is a variable. |
+| [#67](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#67) | `bagof/3` answer-order example | `stc/bagof_answer_order` verifies the proposed clarifying example produces `[2,1]`. |
+| [#73](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73) | float-reading limits discussed from issue #54 | Positive/negative literal and `number_chars/2` overflow are kept as explicit draft cases; underflow is tested separately. See the note below. |
+
+## Float-reading note for #73
+
+EyeProlog currently has a finite-double numeric profile. The draft-facing cases
+record the behavior discussed in issue #54:
+
+- a positive finite numeric token beyond the representable range raises
+  `representation_error(max_float)`;
+- the corresponding negative overflow raises `representation_error(min_float)`;
+- input underflow may round to `0.0`;
+- overflow produced by arithmetic evaluation remains
+  `evaluation_error(float_overflow)`.
+
+These `max_float` / `min_float` names are treated as a **provisional draft
+extension**, not as a claim about the currently published ISO core standard.
+The earlier WG17 float-update material also uses
+`representation_error(float_overflow)` for unsupported infinity input, while a
+separate reading-floats proposal discusses `max_float` for a finite value above
+the implementation's largest finite float. Those cases should remain distinct
+when WG17 settles the wording.
+
+Relevant background:
+
+- [WG17 float update](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/core_update_float-2014-07-21)
+- [Issue #54](https://github.com/eyereasoner/eyeprolog/issues/54)
+
+## Maintenance rule
+
+When the STC draft changes, review executable changes before a release. Draft
+expectations must never silently replace the normative ISO/WG17 expectations;
+where the two differ, keep the draft test clearly labelled `stc/` until the
+standardization status changes.

package/test/conformance/cases/stc/bagof_answer_order.pl

@@ -0,0 +1,6 @@
+% STC #67: the clarifying bagof/3 example retains proof/answer order.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#67
+%% goal: bagof_answer_order
+
+bagof_answer_order :-
+  bagof(X, (X = 2 ; X = 1), [2, 1]).

package/test/conformance/cases/stc/clause_variable_identity.pl

@@ -0,0 +1,9 @@
+% STC #37: clause/2 must preserve sharing between variables in head and body.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#37
+%% goal: clause_variable_identity
+
+a(X) :- b(X).
+
+clause_variable_identity :-
+  clause(a(A), b(B)),
+  A == B.

package/test/conformance/cases/stc/float_underflow_input.pl

@@ -0,0 +1,10 @@
+% Float-reading draft review associated with STC #73 / issue #54. EyeProlog's
+% finite-double profile permits input underflow to round to zero.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: float_underflow_input
+
+float_underflow_input :-
+  number_chars(Positive, "1.0e-99999"),
+  Positive =:= 0.0,
+  number_chars(Negative, "-1.0e-99999"),
+  Negative =:= 0.0.

package/test/conformance/cases/stc/integer_to_float_evaluable.pl

@@ -0,0 +1,8 @@
+% STC #42: float evaluable functors such as sin/1 accept integer expressions
+% through the specified integer-to-float conversion.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#42
+%% goal: integer_to_float_evaluable
+
+integer_to_float_evaluable :-
+  X is sin(1),
+  float(X).

package/test/conformance/cases/stc/mixed_integer_float_comparison.pl

@@ -0,0 +1,16 @@
+% STC #50: mixed arithmetic comparisons must not become incorrect by rounding
+% an integer through the float representation before comparing it.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#50
+%% goal: mixed_integer_float_comparison
+
+mixed_integer_float_comparison :-
+  9007199254740993 > 9007199254740992.0,
+  9007199254740992.0 < 9007199254740993,
+  9007199254740993 =\= 9007199254740992.0,
+  -9007199254740993 < -9007199254740992.0,
+  Max is max(9007199254740993, 9007199254740992.0),
+  integer(Max),
+  Max =:= 9007199254740993,
+  Min is min(9007199254740993, 9007199254740992.0),
+  float(Min),
+  Min =:= 9007199254740992.0.

package/test/conformance/errors/stc/float_overflow_negative_literal.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+answer(-1.0e99999).

package/test/conformance/errors/stc/float_overflow_negative_number_chars.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: number_chars(_, "-1.0e99999")

package/test/conformance/errors/stc/float_overflow_positive_literal.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+answer(1.0e99999).

package/test/conformance/errors/stc/float_overflow_positive_number_chars.pl

@@ -0,0 +1,3 @@
+% Draft float-reading limit review associated with STC #73 / issue #54.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+%% goal: number_chars(_, "1.0e99999")

package/test/conformance/expected/stc/bagof_answer_order.pl

@@ -0,0 +1 @@
+bagof_answer_order.

package/test/conformance/expected/stc/clause_variable_identity.pl

@@ -0,0 +1 @@
+clause_variable_identity.

package/test/conformance/expected/stc/float_underflow_input.pl

@@ -0,0 +1 @@
+float_underflow_input.

package/test/conformance/expected/stc/integer_to_float_evaluable.pl

@@ -0,0 +1 @@
+integer_to_float_evaluable.

package/test/conformance/expected/stc/mixed_integer_float_comparison.pl

@@ -0,0 +1 @@
+mixed_integer_float_comparison.

package/test/conformance/expected-errors/stc/float_overflow_negative_literal.txt

@@ -0,0 +1 @@
+error(representation_error(min_float))

package/test/conformance/expected-errors/stc/float_overflow_negative_number_chars.txt

@@ -0,0 +1 @@
+error(representation_error(min_float))

package/test/conformance/expected-errors/stc/float_overflow_positive_literal.txt

@@ -0,0 +1 @@
+error(representation_error(max_float))

package/test/conformance/expected-errors/stc/float_overflow_positive_number_chars.txt

@@ -0,0 +1 @@
+error(representation_error(max_float))

package/test/run-regression.mjs

@@ -849,6 +849,29 @@ c4 ?- call((!;1)).
         assertEqual(hostTermError?.formal, 'evaluation_error(float_overflow)', 'host-created non-finite term');
       },
     },
+    {
+      name: 'mixed integer/float arithmetic comparison preserves exact order (STC #50)',
+      run: () => {
+        const hugeInteger = `1${'0'.repeat(309)}`;
+        const program = `
+          check :-
+            9007199254740993 > 9007199254740992.0,
+            9007199254740992.0 < 9007199254740993,
+            9007199254740993 =\\= 9007199254740992.0,
+            -9007199254740993 < -9007199254740992.0,
+            ${hugeInteger} > 1.0e308,
+            -${hugeInteger} < -1.0e308,
+            Max is max(9007199254740993, 9007199254740992.0),
+            integer(Max),
+            Max =:= 9007199254740993,
+            Min is min(9007199254740993, 9007199254740992.0),
+            float(Min),
+            Min =:= 9007199254740992.0.
+        `;
+        const result = runEyeProlog(program, { goal: 'check' });
+        assertEqual(result.stdout, 'check.\n', 'mixed integer/float ordering');
+      },
+    },
     {
       name: 'readers keep a full stop inside a character-code constant (WG17 #367)',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -7414,7 +7414,7 @@ upstream syntax cases. Reviewed cases can pin exact strict-reader outcomes, whil
 newly upgraded cases execute directly against the upstream Codex expectation.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 791 cases, including 386 focused ISO
+contains 800 cases, including 386 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 210 normal