eyeprolog 1.5.41 → 1.5.42

package/examples/book/README.md

@@ -252,3 +252,4 @@ npm run generate
 - [02-program.pl](chapter-40/02-program.pl)
 - [03-program-2.pl](chapter-40/03-program-2.pl)
 - [04-program-3.pl](chapter-40/04-program-3.pl)
+- [05-program-4.pl](chapter-40/05-program-4.pl)

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

@@ -1,5 +1,3 @@
 % From The Art of EyeProlog, Chapter 40.
-?- read(X).
-   inputs("1."), X = 1, unexpected.
-   inputs("1."), peeks(" "), X = 1.
-   inputs("1. "), peeks(" "), X = 1, unexpected.
+?- V is 0+(3.2+11).
+   V ~ '14.2000'.

package/examples/book/chapter-40/04-program-3.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 40.
-inf :- inf, inf.
-
-?- inf.
-   loops.
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.

package/examples/book/chapter-40/05-program-4.pl

@@ -0,0 +1,5 @@
+% From The Art of EyeProlog, Chapter 40.
+inf :- inf, inf.
+
+?- inf.
+   loops.

package/package.json

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

package/src/parser.js

@@ -1051,10 +1051,21 @@ class Parser {
     this.advance();
 
     const answers = [];
-    while (this.token.type !== TOK.EOF && this.sourceLineIsIndented(this.token.line)) {
-      answers.push(this.parseTerm(0, true));
-      this.expect(TOK.DOT, '.');
-      this.advance();
+    // 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);
     }
     if (answers.length === 0) throw new Error(`parse line ${line}: quad requires an indented answer description`);
 

package/src/quads.js

@@ -4,8 +4,8 @@
 // A `maybe` annotation denotes a successful answer with residual constraints;
 // it does not relax the ordinary answer-substitution comparison.
 import {
-  ATOM, COMPOUND, VAR, Env, atom, compound, copyResolved, deref,
-  flattenConjunction, listFromItems, properListItems, termIsGround,
+  ATOM, COMPOUND, NUMBER, VAR, Env, atom, compound, copyResolved, deref,
+  flattenConjunction, isDecimalInteger, listFromItems, properListItems, termIsGround,
   unify, variable,
 } from './term.js';
 import { parseGoalText } from './parser.js';
@@ -191,13 +191,14 @@ function malformedAlternative(query, alternative) {
   for (const leaf of splitOperator(alternative, ';').map(describeLeaf)) {
     if (leaf.malformed != null) return leaf.malformed;
     const names = new Set();
-    for (const binding of leaf.bindings) {
+    const substitutions = [...leaf.bindings, ...leaf.approximations];
+    for (const binding of substitutions) {
       const name = binding.args[0].name;
       if (!queryNames.has(name) || names.has(name)) return binding;
       names.add(name);
     }
     if (!leaf.sto) {
-      for (const binding of leaf.bindings) {
+      for (const binding of substitutions) {
         if (namedVariables(binding.args[1]).some((variable) => names.has(variable.name))) return binding;
       }
     }
@@ -208,6 +209,7 @@ function malformedAlternative(query, alternative) {
 function describeLeaf(term) {
   const leaf = {
     bindings: [],
+    approximations: [],
     unexpected: false,
     more: false,
     sto: false,
@@ -245,6 +247,11 @@ function describeLeaf(term) {
       else leaf.bindings.push(item);
       continue;
     }
+    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;
+    }
     if (item.type === COMPOUND && item.name === 'inputs' && item.arity === 1) {
       const text = characterText(item.args[0]);
       if (text == null || leaf.input != null) leaf.malformed ??= item;
@@ -265,7 +272,8 @@ function describeLeaf(term) {
     if (isErrorDescription(item)) leaf.error = item;
     else leaf.malformed ??= item;
   }
-  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.truth || leaf.false || leaf.maybe || leaf.loops || leaf.waits ||
+  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.approximations.length > 0 ||
+    leaf.truth || leaf.false || leaf.maybe || leaf.loops || leaf.waits ||
     leaf.error != null || leaf.output != null;
   if (!leaf.hasExpectation && !leaf.more && !leaf.sto && leaf.unsupported == null) leaf.malformed ??= term;
   if ([leaf.false, leaf.truth, leaf.error != null].filter(Boolean).length > 1) leaf.malformed ??= term;
@@ -404,7 +412,7 @@ function matchLeaf(program, query, leaf, actual, position) {
   // its absence requires an unconstrained answer. In either case the stated
   // substitutions remain exact and are checked below.
   if (leaf.maybe !== hasPendingConstraints(solution.env)) return false;
-  return substitutionMatches(query, leaf.bindings, solution.env);
+  return substitutionMatches(query, leaf.bindings, leaf.approximations, solution.env);
 }
 
 function hasPendingConstraints(env) {
@@ -428,22 +436,73 @@ function alternativeDescribesLoop(alternative) {
   return splitOperator(alternative, ';').some((term) => describeLeaf(term).loops);
 }
 
-function substitutionMatches(query, bindings, actualEnv) {
+function substitutionMatches(query, bindings, approximations, actualEnv) {
   const queryVariables = namedVariables(query);
   const queryNames = new Set(queryVariables.map((variable) => variable.name));
+  const queryVariablesByName = new Map(queryVariables.map((variable) => [variable.name, variable]));
   const expectedEnv = new Env();
   const rebound = new Set();
-  for (const binding of bindings) {
+  for (const binding of [...bindings, ...approximations]) {
     const variable = binding.args[0];
     if (!queryNames.has(variable.name) || rebound.has(variable.name)) return false;
     rebound.add(variable.name);
-    if (!unify(variable, binding.args[1], expectedEnv)) return false;
+    if (binding.name === '=') {
+      if (!unify(variable, binding.args[1], expectedEnv)) return false;
+      continue;
+    }
+    const actualVariable = queryVariablesByName.get(variable.name);
+    const actualValue = deref(actualVariable, actualEnv);
+    if (!approximatelyMatches(actualValue, binding.args[1])) return false;
+    // 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.
+    if (!unify(variable, copyResolved(actualValue, actualEnv), expectedEnv)) return false;
   }
   const expected = compound('$quad_answer', queryVariables.map((variable) => copyResolved(variable, expectedEnv)));
   const actual = compound('$quad_answer', queryVariables.map((variable) => copyResolved(variable, 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.
+function approximateDecimalInterval(term) {
+  if (term?.type !== ATOM) return null;
+  const text = term.name;
+  const match = /^([+-]?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+  if (match == null) return null;
+
+  const [, sign, integerDigits, fraction = '', exponentText = '0'] = match;
+  const digits = `${integerDigits}${fraction}`;
+  const unsignedMantissa = BigInt(digits || '0');
+  const mantissa = sign === '-' ? -unsignedMantissa : unsignedMantissa;
+  const exponent = Number(exponentText);
+  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) };
+}
+
+function approximatelyMatches(actual, expectedAtom) {
+  if (actual?.type !== NUMBER || isDecimalInteger(actual.name)) return false;
+  const actualValue = Number(actual.name);
+  if (!Number.isFinite(actualValue)) return false;
+  const interval = approximateDecimalInterval(expectedAtom);
+  return interval != null && actualValue >= interval.lower && actualValue <= interval.upper;
+}
+
 function namedVariables(term) {
   const found = [];
   const seen = new Set();
@@ -727,8 +786,12 @@ function formatFailure(program, quad, result, description = quad.answers[0]) {
 }
 
 function formatQuadTerm(program, term) {
+  const operators = [...program.operators.values()];
+  if (!operators.some(({ name, specifier }) => name === '~' && ['xfx', 'xfy', 'yfx'].includes(specifier))) {
+    operators.push({ priority: 700, specifier: 'xfx', name: '~' });
+  }
   return formatTermForWrite(term, new Env(), {
     quoted: true,
-    operators: [...program.operators.values()],
+    operators,
   });
 }

package/test/run-regression.mjs

@@ -994,6 +994,88 @@ why(
         assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads supports decimal-precision approximate float descriptions (issue #90)',
+      run: () => {
+        const source = `?- V is 0+(3.2+11).
+` +
+          `   V ~ '14.2000'.
+
+` +
+          `?- V is 0+(3.2+11).
+` +
+          `   V ~ '1.42000e1'.
+
+` +
+          `?- V is -14.2.
+` +
+          `   V ~ '-14.2000'.
+
+` +
+          `?- V is 1.0e-3.
+` +
+          `   V ~ '1.000e-3'.
+
+` +
+          `?- V is 14.19995.
+` +
+          `   V ~ '14.2000'.
+
+` +
+          `?- V is 14.20005.
+` +
+          `   V ~ '14.2000'.
+
+` +
+          `?- V is 14.2.
+` +
+          `   V ~ '14.1999', unexpected.
+
+` +
+          `?- V is 14.
+` +
+          `   V ~ '14.0', unexpected.
+
+` +
+          `?- V is float(14).
+` +
+          `   V ~ '14.0'.
+`;
+        const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'approx-quad.pl' }]));
+        assertEqual(result.total, 9, 'approximate answer-description total');
+        assertEqual(result.passed, 9, 'approximate answer-description passed');
+        assertEqual(result.failed, 0, 'approximate answer-description failed');
+        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.
+`);
+        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'.
+`);
+        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'.
+`);
+        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');
+      },
+    },
     {
       name: 'runQuads treats unexpected as a negative assertion on the next leaf (issue #83)',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -9597,6 +9597,26 @@ constraint remain. For example, a pending `dif/2` constraint can be checked as:
    maybe, unexpected.
 ```
 
+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:
+
+```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.
+
 EyeProlog treats native variable constraints, attributed-variable residue, and
 delayed goals as pending residue for this purpose. Multiple
 indented descriptions after one query are independent checks: each re-runs the