eyeprolog 1.3.9 → 1.3.11

package/package.json

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

package/src/program.js

@@ -314,15 +314,10 @@ export class Program {
     const wfsNegativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
+      let compactDependencies = null;
       for (const clause of group.clauses) {
         if (isCompactBinaryClause(clause)) {
-          if (clause.bodyName != null) {
-            const dep = this.findGroup(clause.bodyName, 2, group.module);
-            if (dep) {
-              deps[groupIndex].add(indexByGroup.get(dep));
-              cutDeps[groupIndex].add(indexByGroup.get(dep));
-            }
-          }
+          if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
           continue;
         }
         for (const goal of clause.body) {
@@ -349,6 +344,13 @@ export class Program {
           }
         }
       }
+      for (const name of compactDependencies ?? []) {
+        const dep = this.findGroup(name, 2, group.module);
+        if (!dep) continue;
+        const dependencyIndex = indexByGroup.get(dep);
+        deps[groupIndex].add(dependencyIndex);
+        cutDeps[groupIndex].add(dependencyIndex);
+      }
     }
     const finiteDatalogCache = new Map();
     const rangeRestrictedDatalogCache = new Map();
@@ -1301,12 +1303,10 @@ function datalogDependencyClauseCount(program, group, seen = new Set()) {
   if (seen.has(group)) return 0;
   seen.add(group);
   let count = group.clauses.length;
+  let compactDependencies = null;
   for (const clause of group.clauses) {
     if (isCompactBinaryClause(clause)) {
-      if (clause.bodyName != null) {
-        const target = program.findGroup(clause.bodyName, 2, group.module);
-        if (target) count += datalogDependencyClauseCount(program, target, seen);
-      }
+      if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
       continue;
     }
     for (const goal of clause.body) {
@@ -1315,6 +1315,10 @@ function datalogDependencyClauseCount(program, group, seen = new Set()) {
       if (target) count += datalogDependencyClauseCount(program, target, seen);
     }
   }
+  for (const name of compactDependencies ?? []) {
+    const target = program.findGroup(name, 2, group.module);
+    if (target) count += datalogDependencyClauseCount(program, target, seen);
+  }
   return count;
 }
 
@@ -1324,12 +1328,10 @@ function isFiniteDatalogGroup(program, group, cache = new Map(), visiting = new
   if (visiting.has(group)) return true;
   visiting.add(group);
   let finite = true;
+  let compactDependencies = null;
   for (const clause of group.clauses) {
     if (isCompactBinaryClause(clause)) {
-      if (clause.bodyName != null) {
-        const target = program.findGroup(clause.bodyName, 2, group.module);
-        if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
-      }
+      if (clause.bodyName != null) (compactDependencies ??= new Set()).add(clause.bodyName);
       continue;
     }
     if (clause.head.type === COMPOUND && !clause.head.args.every(isFiniteDatalogArgument)) { finite = false; break; }
@@ -1345,6 +1347,12 @@ function isFiniteDatalogGroup(program, group, cache = new Map(), visiting = new
     }
     if (!finite) break;
   }
+  if (finite) {
+    for (const name of compactDependencies ?? []) {
+      const target = program.findGroup(name, 2, group.module);
+      if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+    }
+  }
   visiting.delete(group);
   cache.set(group, finite);
   return finite;
@@ -1358,7 +1366,35 @@ function isRangeRestrictedFiniteDatalogGroup(program, group, cache = new Map(),
   visiting.add(group);
   let finite = true;
 
+  let compactDependencyResults = null;
   for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      const head0Variable = clause.head0Type === VAR;
+      const head1Variable = clause.head1Type === VAR;
+      if (clause.bodyName == null) {
+        if (head0Variable || head1Variable) { finite = false; break; }
+        continue;
+      }
+      const head0RangeRestricted = !head0Variable ||
+        (clause.body0Type === VAR && clause.body0Name === clause.head0Name) ||
+        (clause.body1Type === VAR && clause.body1Name === clause.head0Name);
+      const head1RangeRestricted = !head1Variable ||
+        (clause.body0Type === VAR && clause.body0Name === clause.head1Name) ||
+        (clause.body1Type === VAR && clause.body1Name === clause.head1Name);
+      if (!head0RangeRestricted || !head1RangeRestricted) {
+        finite = false;
+        break;
+      }
+      let targetFinite = compactDependencyResults?.get(clause.bodyName);
+      if (targetFinite == null) {
+        const target = program.findGroup(clause.bodyName, 2, group.module);
+        targetFinite = target != null && isRangeRestrictedFiniteDatalogGroup(program, target, cache, visiting);
+        (compactDependencyResults ??= new Map()).set(clause.bodyName, targetFinite);
+      }
+      if (!targetFinite) { finite = false; break; }
+      continue;
+    }
+
     const head = clause.head;
     if ((head.type !== COMPOUND && head.type !== ATOM) ||
         (head.type === COMPOUND && !head.args.every(isFiniteDatalogArgument))) {

package/src/term.js

@@ -683,7 +683,13 @@ export function numberTextFromDouble(value) {
   if (Object.is(value, -0)) value = 0;
   let text = Number(value).toPrecision(17);
   if (text.includes('e') || text.includes('E')) {
-    text = text.replace(/(\.\d*?[1-9])0+(e[+-]?\d+)$/i, '$1$2').replace(/\.0+(e[+-]?\d+)$/i, '$1');
+    text = text
+      .replace(/(\.\d*?[1-9])0+(e[+-]?\d+)$/i, '$1$2')
+      // ISO floating-point syntax requires a fractional part before the
+      // exponent. Keep one zero when the fraction is otherwise all zeros so
+      // generated text remains readable by EyeProlog itself (for example
+      // 1.0e-8 rather than JavaScript's 1e-8).
+      .replace(/\.0+(e[+-]?\d+)$/i, '.0$1');
   } else if (text.includes('.')) {
     text = text.replace(/0+$/, '').replace(/\.$/, '');
   }

package/test/run-regression.mjs

@@ -31,6 +31,7 @@ import {
   compound,
   listFromItems,
   numberTerm,
+  numberTextFromDouble,
   stringTerm,
   variable,
   copyResolved,
@@ -697,6 +698,35 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'number_chars and number_codes keep exponent floats syntactically readable (issue #50)',
+      run: () => {
+        const source = `
+?- number_chars(1.0e-8,Cs).
+   Cs = "1.0e-8".
+?- number_chars(N,"1.0e-8"), number_chars(N,Cs).
+   N = 1.0e-8, Cs = "1.0e-8".
+?- number_codes(N,[49,46,48,101,45,56]), number_codes(N,Codes).
+   N = 1.0e-8, Codes = [49,46,48,101,45,56].
+`;
+        const result = publicApi.runQuads(source);
+        assertEqual(result.total, 3, 'quad total');
+        assertEqual(result.passed, 3, 'quad passed');
+        assertEqual(result.failed, 0, 'quad failed');
+
+        const generated = numberTerm(numberTextFromDouble(1e-8));
+        assertEqual(generated.name, '1.0e-8', 'generated float spelling');
+        assertEqual(parseNumberTokenText(generated.name).name, '1.0e-8', 'generated spelling parses as a float');
+
+        for (const value of [1e-8, -1e-8, 1e20, 1e21, Number.MIN_VALUE, Number.MAX_VALUE]) {
+          const text = numberTextFromDouble(value);
+          if (/[eE]/.test(text)) {
+            assertEqual(/^-?\d+\.\d+[eE][+-]?\d+$/.test(text), true, `exponent float syntax ${text}`);
+          }
+          assertEqual(Number(parseNumberTokenText(text).name), value, `generated float round-trip ${text}`);
+        }
+      },
+    },
     {
       name: 'number syntax and number_chars normalize floating-point negative zero',
       run: () => {
@@ -4484,6 +4514,23 @@ function whiteBoxCases() {
         assertEqual(ground.stats.datalog_evaluations, 0, 'ground query keeps the ordinary indexed chain path');
       },
     },
+    {
+      name: 'compact finite Datalog planning preserves lazy clause terms',
+      run: () => {
+        const facts = Array.from({ length: 130 }, (_, i) => `compact_edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${facts}\ncompact_edge(X,Y) :- compact_edge(X,Y).\n`;
+        const program = Program.parseSources([{ text: source, filename: 'compact-datalog.pl' }], {
+          sourceMetadata: false,
+        });
+        const group = program.findGroup('compact_edge', 2);
+        assertEqual(group.datalogLeastModel, true, 'compact recursive Datalog remains eligible');
+        assertEqual(
+          group.clauses.filter((clause) => clause._head != null || clause._body != null).length,
+          0,
+          'planning keeps compact clause terms lazy',
+        );
+      },
+    },
     {
       name: 'findall length counting preserves multiplicity and observable bags',
       run: () => {