eyeprolog 1.5.43 → 1.5.44

package/examples/book/chapter-40/03-program-2.pl

@@ -1,3 +1,3 @@
 % From The Art of EyeProlog, Chapter 40.
 ?- V is 0+(3.2+11).
-   V ~ '14.2000'.
+   V ~~ '14.2000'.

package/package.json

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

package/src/parser.js

@@ -176,6 +176,12 @@ export const PART3_OPERATOR_DEFINITIONS = [
 // ISO 1200 fx definition.
 export const QUAD_OPERATOR_DEFINITIONS = [
   [1200, 'xfx', '?-'],
+  // Quad approximate-answer notation. Keep this visible through current_op/3
+  // at the same priority/specifier as the ISO comparison operators. There is
+  // deliberately no built-in predicate behind it: ordinary source may define
+  // or call ~~ / 2 in the usual way, while quads interpret it specially only
+  // inside answer descriptions.
+  [700, 'xfx', '~~'],
 ];
 
 const CLPZ_OPERATOR_DEFINITIONS = [
@@ -1053,21 +1059,10 @@ class Parser {
     this.advance();
 
     const answers = [];
-    // Issue #90 extends only the embedded answer-description grammar with
-    // decimal-precision approximate equality. Do not leak `~` into ordinary
-    // EyeProlog source syntax: temporarily parse it like the standard 700 xfx
-    // comparison operators while consuming the indented quad answers.
-    const previousApproximateOperator = this.infixOperators.get('~');
-    this.infixOperators.set('~', { precedence: operatorStrength(700), associativity: 'none' });
-    try {
-      while (this.token.type !== TOK.EOF && this.sourceLineIsIndented(this.token.line)) {
-        answers.push(this.parseTerm(0, true));
-        this.expect(TOK.DOT, '.');
-        this.advance();
-      }
-    } finally {
-      if (previousApproximateOperator == null) this.infixOperators.delete('~');
-      else this.infixOperators.set('~', previousApproximateOperator);
+    while (this.token.type !== TOK.EOF && this.sourceLineIsIndented(this.token.line)) {
+      answers.push(this.parseTerm(0, true));
+      this.expect(TOK.DOT, '.');
+      this.advance();
     }
     if (answers.length === 0) throw new Error(`parse line ${line}: quad requires an indented answer description`);
 

package/src/quads.js

@@ -5,7 +5,7 @@
 // it does not relax the ordinary answer-substitution comparison.
 import {
   ATOM, COMPOUND, NUMBER, VAR, Env, atom, compound, copyResolved, deref,
-  flattenConjunction, isDecimalInteger, listFromItems, properListItems, termIsGround,
+  flattenConjunction, isDecimalInteger, listFromItems, numberTextFromDouble, properListItems, termIsGround,
   unify, variable,
 } from './term.js';
 import { parseGoalText } from './parser.js';
@@ -247,7 +247,7 @@ function describeLeaf(term) {
       else leaf.bindings.push(item);
       continue;
     }
-    if (item.type === COMPOUND && item.name === '~' && item.arity === 2) {
+    if (item.type === COMPOUND && item.name === '~~' && item.arity === 2) {
       if (item.args[0].type !== VAR || approximateDecimalInterval(item.args[1]) == null) leaf.malformed ??= item;
       else leaf.approximations.push(item);
       continue;
@@ -456,7 +456,7 @@ function substitutionMatches(query, bindings, approximations, actualEnv) {
     // Once the approximate predicate has accepted the actual float, bind the
     // expected-side variable to that exact observed term. This lets the
     // ordinary variant matcher continue to check the rest of the answer,
-    // including variable sharing, without turning `~` into a fuzzy unifier.
+    // including variable sharing, without turning `~~` into a fuzzy unifier.
     if (!unify(variable, copyResolved(actualValue, actualEnv), expectedEnv)) return false;
   }
   const expected = compound('$quad_answer', queryVariables.map((variable) => copyResolved(variable, expectedEnv)));
@@ -464,11 +464,18 @@ function substitutionMatches(query, bindings, approximations, actualEnv) {
   return patternVariant(expected, new Env(), actual, new Env());
 }
 
-// Parse a quoted decimal spelling as the interval represented by rounding to
-// its final written mantissa digit.  For example, '14.2000' denotes
-// [14.19995, 14.20005], and '1.42000e1' denotes the same interval.  Construct
-// the exact decimal endpoints before converting them to binary floats instead
-// of adding a tiny tolerance to an already-rounded Number.
+// A quad approximation atom denotes the closed decimal interval obtained by
+// rounding to its final written mantissa digit. For example, '14.2000' denotes
+// [14.19995, 14.20005], and '1.42000e1' denotes the same interval.
+//
+// The description is useful only if that exact decimal interval has meaningful
+// resolution in EyeProlog's finite float set. Convert the lower endpoint,
+// written midpoint, and upper endpoint to actual representable floats, using
+// directed adjustment at the endpoints so the selected minimum/maximum remain
+// inside the exact decimal interval. Require all three to be finite and
+// strictly ascending. This rejects over-precise "fake float" descriptions whose
+// decimal distinctions collapse to one implementation float, as well as
+// overflow/continuation-value ranges.
 function approximateDecimalInterval(term) {
   if (term?.type !== ATOM) return null;
   const text = term.name;
@@ -483,16 +490,112 @@ function approximateDecimalInterval(term) {
   if (!Number.isSafeInteger(exponent)) return null;
   const scale = exponent - fraction.length;
 
-  // center = mantissa * 10^scale; half an ulp of the written decimal is
-  // 5 * 10^(scale-1). Keeping the coefficient integral preserves every
-  // significant trailing zero in the expected spelling.
-  const lowerCoefficient = mantissa * 10n - 5n;
-  const upperCoefficient = mantissa * 10n + 5n;
-  const boundExponent = scale - 1;
-  const lower = Number(`${lowerCoefficient}e${boundExponent}`);
-  const upper = Number(`${upperCoefficient}e${boundExponent}`);
-  if (!Number.isFinite(lower) || !Number.isFinite(upper)) return null;
-  return { lower: Math.min(lower, upper), upper: Math.max(lower, upper) };
+  // center = mantissa * 10^scale; half a unit in the final written decimal
+  // place is 5 * 10^(scale-1). Keep the decimal coefficients exact until the
+  // representable-float selection below.
+  const lowerDecimal = { coefficient: mantissa * 10n - 5n, exponent: scale - 1 };
+  const middleDecimal = { coefficient: mantissa, exponent: scale };
+  const upperDecimal = { coefficient: mantissa * 10n + 5n, exponent: scale - 1 };
+
+  const rawLower = decimalToFiniteFloat(lowerDecimal);
+  const middle = decimalToFiniteFloat(middleDecimal);
+  const rawUpper = decimalToFiniteFloat(upperDecimal);
+  if (rawLower == null || middle == null || rawUpper == null) return null;
+  // If nearest rounding already collapses any two of the three points, no
+  // directed endpoint adjustment can create three floats inside the interval.
+  // Reject here before exact decimal comparison, which also keeps absurdly
+  // over-precise exponents from constructing enormous BigInt powers.
+  if (!(rawLower.value < middle.value && middle.value < rawUpper.value)) return null;
+
+  // Number() rounds to nearest. If an endpoint rounded outside the closed
+  // decimal interval, move one representable float inward. This avoids
+  // accepting a float that is merely close to a decimal boundary but lies
+  // mathematically outside it.
+  let minimum = rawLower;
+  if (compareFiniteFloatToDecimal(minimum.value, lowerDecimal) < 0) {
+    minimum = canonicalFiniteFloat(nextUp(minimum.value));
+  }
+  let maximum = rawUpper;
+  if (compareFiniteFloatToDecimal(maximum.value, upperDecimal) > 0) {
+    maximum = canonicalFiniteFloat(nextDown(maximum.value));
+  }
+  if (minimum == null || maximum == null) return null;
+
+  if (!(minimum.value < middle.value && middle.value < maximum.value)) return null;
+  return { minimum, middle, maximum };
+}
+
+function decimalToFiniteFloat(decimal) {
+  const value = Number(`${decimal.coefficient}e${decimal.exponent}`);
+  return canonicalFiniteFloat(value);
+}
+
+function canonicalFiniteFloat(value) {
+  if (!Number.isFinite(value)) return null;
+  const text = numberTextFromDouble(value);
+  if (text == null || isDecimalInteger(text) || Number(text) !== value) return null;
+  return { value, text };
+}
+
+// Compare an IEEE-754 binary64 value with coefficient * 10^exponent exactly.
+// The float is converted to an integer over a power-of-two denominator, so no
+// second floating rounding is involved in deciding whether a rounded boundary
+// candidate lies inside or outside the decimal interval.
+const FLOAT_BITS = new DataView(new ArrayBuffer(8));
+function finiteFloatRatio(value) {
+  FLOAT_BITS.setFloat64(0, value, false);
+  const bits = FLOAT_BITS.getBigUint64(0, false);
+  const negative = (bits >> 63n) !== 0n;
+  const exponentBits = Number((bits >> 52n) & 0x7ffn);
+  const fraction = bits & 0xfffffffffffffn;
+  if (exponentBits === 0 && fraction === 0n) return { numerator: 0n, denominatorPower: 0 };
+
+  let significand;
+  let exponent2;
+  if (exponentBits === 0) {
+    significand = fraction;
+    exponent2 = -1074;
+  } else {
+    significand = (1n << 52n) | fraction;
+    exponent2 = exponentBits - 1023 - 52;
+  }
+  if (negative) significand = -significand;
+  if (exponent2 >= 0) {
+    return { numerator: significand << BigInt(exponent2), denominatorPower: 0 };
+  }
+  return { numerator: significand, denominatorPower: -exponent2 };
+}
+
+function compareFiniteFloatToDecimal(value, decimal) {
+  const { numerator, denominatorPower } = finiteFloatRatio(value);
+  let left;
+  let right;
+  if (decimal.exponent >= 0) {
+    left = numerator;
+    right = decimal.coefficient * (10n ** BigInt(decimal.exponent));
+    right <<= BigInt(denominatorPower);
+  } else {
+    const decimalDenominator = 10n ** BigInt(-decimal.exponent);
+    left = numerator * decimalDenominator;
+    right = decimal.coefficient << BigInt(denominatorPower);
+  }
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+const NEXT_FLOAT_BITS = new DataView(new ArrayBuffer(8));
+function nextUp(value) {
+  if (Number.isNaN(value) || value === Infinity) return value;
+  if (value === -Infinity) return -Number.MAX_VALUE;
+  if (value === 0) return Number.MIN_VALUE;
+  NEXT_FLOAT_BITS.setFloat64(0, value, false);
+  let bits = NEXT_FLOAT_BITS.getBigUint64(0, false);
+  bits += value > 0 ? 1n : -1n;
+  NEXT_FLOAT_BITS.setBigUint64(0, bits, false);
+  return NEXT_FLOAT_BITS.getFloat64(0, false);
+}
+
+function nextDown(value) {
+  return -nextUp(-value);
 }
 
 function approximatelyMatches(actual, expectedAtom) {
@@ -500,7 +603,8 @@ function approximatelyMatches(actual, expectedAtom) {
   const actualValue = Number(actual.name);
   if (!Number.isFinite(actualValue)) return false;
   const interval = approximateDecimalInterval(expectedAtom);
-  return interval != null && actualValue >= interval.lower && actualValue <= interval.upper;
+  return interval != null &&
+    actualValue >= interval.minimum.value && actualValue <= interval.maximum.value;
 }
 
 function namedVariables(term) {

package/test/run-regression.mjs

@@ -995,51 +995,51 @@ why(
       },
     },
     {
-      name: 'runQuads supports decimal-precision approximate float descriptions (issue #90)',
+      name: 'runQuads supports realistic decimal-precision float descriptions with ~~ (issue #90)',
       run: () => {
         const source = `?- V is 0+(3.2+11).
 ` +
-          `   V ~ '14.2000'.
+          `   V ~~ '14.2000'.
 
 ` +
           `?- V is 0+(3.2+11).
 ` +
-          `   V ~ '1.42000e1'.
+          `   V ~~ '1.42000e1'.
 
 ` +
           `?- V is -14.2.
 ` +
-          `   V ~ '-14.2000'.
+          `   V ~~ '-14.2000'.
 
 ` +
           `?- V is 1.0e-3.
 ` +
-          `   V ~ '1.000e-3'.
+          `   V ~~ '1.000e-3'.
 
 ` +
-          `?- V is 14.19995.
+          `?- V is 14.199950000000001.
 ` +
-          `   V ~ '14.2000'.
+          `   V ~~ '14.2000'.
 
 ` +
           `?- V is 14.20005.
 ` +
-          `   V ~ '14.2000'.
+          `   V ~~ '14.2000'.
 
 ` +
           `?- V is 14.2.
 ` +
-          `   V ~ '14.1999', unexpected.
+          `   V ~~ '14.1999', unexpected.
 
 ` +
           `?- V is 14.
 ` +
-          `   V ~ '14.0', unexpected.
+          `   V ~~ '14.0', unexpected.
 
 ` +
           `?- V is float(14).
 ` +
-          `   V ~ '14.0'.
+          `   V ~~ '14.0'.
 `;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'approx-quad.pl' }]));
         assertEqual(result.total, 9, 'approximate answer-description total');
@@ -1048,32 +1048,70 @@ why(
         assertEqual(result.stdout, 'quads: 9 run, 9 passed, 0 failed.\n', 'approximate quad report');
 
         const malformed = publicApi.runQuads(`?- V is 14.2.
-   V ~ 14.2000.
+   V ~~ 14.2000.
 `);
         assertEqual(malformed.total, 1, 'numeric approximation total');
         assertEqual(malformed.failed, 1, 'numeric RHS is rejected');
         assertIncludes(malformed.stdout, 'MALFORMED', 'numeric RHS diagnostic');
 
         const malformedAtom = publicApi.runQuads(`?- V is 14.2.
-   V ~ 'fourteen'.
+   V ~~ 'fourteen'.
 `);
         assertEqual(malformedAtom.failed, 1, 'non-decimal atom is rejected');
         assertIncludes(malformedAtom.stdout, 'MALFORMED', 'non-decimal atom diagnostic');
 
         const duplicate = publicApi.runQuads(`?- V is 14.2.
-   V = 14.2, V ~ '14.2000'.
+   V = 14.2, V ~~ '14.2000'.
 `);
         assertEqual(duplicate.failed, 1, 'duplicate exact/approximate binding is rejected');
         assertIncludes(duplicate.stdout, 'MALFORMED', 'duplicate binding diagnostic');
 
-        let ordinaryApproximateParsed = false;
-        try {
-          Program.parse(`p(X,Y) :- X ~ Y.\n`);
-          ordinaryApproximateParsed = true;
-        } catch (_) {
-          // `~` is answer-description syntax, not a normal-profile operator.
-        }
-        assertEqual(ordinaryApproximateParsed, false, 'quad approximate operator stays scoped to answer descriptions');
+        const fakeFloat = publicApi.runQuads(`?- V is 1.0.
+   V ~~ '1.0000000000000001'.
+`);
+        assertEqual(fakeFloat.failed, 1, 'fake-float midpoint spelling is malformed');
+        assertIncludes(fakeFloat.stdout, 'MALFORMED', 'fake-float midpoint diagnostic');
+
+        const overPrecise = publicApi.runQuads(`?- V is 1.0000000000000002.
+   V ~~ '1.0000000000000002'.
+`);
+        assertEqual(overPrecise.failed, 1, 'interval without three distinct floats is malformed');
+        assertIncludes(overPrecise.stdout, 'MALFORMED', 'over-precise interval diagnostic');
+
+        const continuationRange = publicApi.runQuads(`?- V is 1.0e308.
+   V ~~ '1.0e309'.
+`);
+        assertEqual(continuationRange.failed, 1, 'non-finite continuation-value interval is malformed');
+        assertIncludes(continuationRange.stdout, 'MALFORMED', 'continuation-value diagnostic');
+
+        assertEqual(
+          run('', { goal: 'current_op(Pri,Fix,=), current_op(Pri,Fix,~~)' }).stdout,
+          'current_op(700, xfx, =), current_op(700, xfx, ~~).\n',
+          '~~ shares the ISO equality operator priority and specifier',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(700,xfx,~~)' }).stats.completed_goal_lists,
+          1,
+          '~~ is visible through current_op/3 in the normal profile',
+        );
+        assertEqual(
+          run('', { goal: 'current_op(_,_,~)' }).stats.completed_goal_lists,
+          0,
+          '~ is not installed by the quad approximation feature',
+        );
+        assertEqual(
+          run('', { isoStrict: true, goal: "current_op(700,xfx,'~~')" }).stats.completed_goal_lists,
+          0,
+          'strict ISO Part 1 does not predefine the ~~ extension',
+        );
+
+        const ordinaryApproximate = Program.parse(`approx(X,Y) :- X ~~ Y.\n`);
+        assertEqual(ordinaryApproximate.groups.has('user:~~/2'), false, '~~ has no built-in or implicit predicate definition');
+        assertEqual(
+          run(`~~(my,definition).\n`, { goal: 'my ~~ definition' }).stats.completed_goal_lists,
+          1,
+          '~~ remains available as an ordinary user-defined predicate',
+        );
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -9608,23 +9608,37 @@ constraint remain. For example, a pending `dif/2` constraint can be checked as:
 
 ISO arithmetic examples sometimes describe a floating result only as
 "approximately equal" to a written decimal. Quad answer descriptions preserve
-the precision of that spelling with `~`: the right-hand side is a decimal atom,
-so trailing zeroes remain significant. `V ~ '14.2000'` accepts a **float** in
-the closed interval `14.19995` through `14.20005`; it does not accept an integer
-term, even when that integer has the same mathematical value. Exponent notation
-uses the last written mantissa digit in the same way, so `'1.42000e1'` denotes
-the same interval. For example:
+the precision of that spelling with `~~`: the right-hand side is a decimal atom,
+so trailing zeroes remain significant. `V ~~ '14.2000'` accepts a **float** in
+the closed decimal interval `14.19995` through `14.20005`; it does not accept an
+integer term, even when that integer has the same mathematical value. Exponent
+notation uses the last written mantissa digit in the same way, so `'1.42000e1'`
+denotes the same interval. For example:
 
 ```eyeprolog
 ?- V is 0+(3.2+11).
-   V ~ '14.2000'.
-```
-
-This `~` notation belongs only to indented quad answer descriptions. It does
-not install an approximate-equality predicate or operator in ordinary Prolog
-source. A numeric right-hand side such as `V ~ 14.2000` is deliberately
-rejected because parsing it as a float would discard the written decimal
-precision that the check is intended to retain.
+   V ~~ '14.2000'.
+```
+
+`~~` is an EyeProlog normal-profile operator at priority 700 with specifier
+`xfx`, matching the priority/specifier of ISO comparison operators such as `=`;
+there is no built-in `~~/2` predicate. Quad answer descriptions interpret the
+operator specially as approximate float matching.
+
+An approximation is accepted as well-formed only when its exact decimal
+interval contains at least three distinct, strictly ascending finite EyeProlog
+floats: the minimum representable float in the interval, the float denoted by
+the written midpoint, and the maximum representable float in the interval. This
+prevents a decimal spelling from claiming precision finer than the
+implementation can represent, including decimal spellings whose apparent
+precision collapses to the same implementation float, and rejects ranges that
+would require non-finite continuation values. Endpoint
+selection is directed inward, so a binary rounding of a decimal bound cannot
+admit a float that lies mathematically outside the closed decimal interval.
+
+A numeric right-hand side such as `V ~~ 14.2000` is deliberately rejected
+because parsing it as a float would discard the written decimal precision that
+the check is intended to retain.
 
 EyeProlog treats native variable constraints, attributed-variable residue, and
 delayed goals as pending residue for this purpose. Multiple