🚧 progress: First draft.

Author: make-github-pseudonymous-again

README.md

@@ -11,6 +11,26 @@ See [docs](https://string-data-structure.github.io/fibonacci-string/index.html).
 > `regeneratorRuntime` to be defined, for instance by importing
 > [regenerator-runtime/runtime](https://www.npmjs.com/package/regenerator-runtime).
 
+```js
+import {build} from '@string-data-structure/fibonacci-string';
+
+const f = build({iadd: (x, y) => x+y, zero: () => 1, one: () => 1});
+
+f(0); // 1
+f(1); // 0
+f(2); // 1
+f(3); // 1
+f(4); // 0
+f(5); // 1
+f(6); // 0
+f(7); // 1
+f(8); // 1
+f(9); // 0
+
+const fn = build({iadd: (x, y) => x+y, zero: () => 1n, one: () => 1n});
+f(4802349082340928340983n); // 0
+```
+
 [![License](https://img.shields.io/github/license/string-data-structure/fibonacci-string.svg)](https://raw.githubusercontent.com/string-data-structure/fibonacci-string/main/LICENSE)
 [![Version](https://img.shields.io/npm/v/@string-data-structure/fibonacci-string.svg)](https://www.npmjs.org/package/@string-data-structure/fibonacci-string)
 [![Tests](https://img.shields.io/github/workflow/status/string-data-structure/fibonacci-string/ci:test?event=push&label=tests)](https://github.com/string-data-structure/fibonacci-string/actions/workflows/ci:test.yml?query=branch:main)

doc/scripts/header.js

@@ -17,7 +17,8 @@ domReady(() => {
 	header.insertBefore(projectname, header.firstChild);
 
 	const testlink = document.querySelector('header > a[data-ice="testLink"]');
-	testlink.href = 'https://app.codecov.io/gh/string-data-structure/fibonacci-string';
+	testlink.href =
+		'https://app.codecov.io/gh/string-data-structure/fibonacci-string';
 	testlink.target = '_BLANK';
 
 	const searchBox = document.querySelector('.search-box');

package.json

@@ -64,12 +64,20 @@
     "release": "np --message ':hatching_chick: release: Bumping to v%s.'",
     "test": "ava"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@functional-abstraction/predicate": "^3.0.2",
+    "@iterable-iterator/slice": "^0.0.1"
+  },
   "devDependencies": {
     "@babel/core": "7.14.3",
     "@babel/preset-env": "7.14.2",
     "@babel/register": "7.13.16",
     "@commitlint/cli": "12.1.4",
+    "@iterable-iterator/list": "^0.0.2",
+    "@iterable-iterator/map": "^0.1.0",
+    "@iterable-iterator/range": "^1.0.0",
+    "@iterable-iterator/select": "^0.0.1",
+    "@iterable-iterator/zip": "^0.0.2",
     "@js-library/commitlint-config": "0.0.4",
     "ava": "3.15.0",
     "babel-plugin-transform-remove-console": "6.9.4",
@@ -202,6 +210,7 @@
       "unicorn"
     ],
     "rules": {
+      "camelcase": "off",
       "unicorn/filename-case": [
         "error",
         {

src/build.js

@@ -0,0 +1,18 @@
+import {takewhile} from '@iterable-iterator/slice';
+import {le} from '@functional-abstraction/predicate';
+
+import gen from './gen.js';
+
+/**
+ * Build.
+ *
+ * @param {Object}
+ * @param {number|bigint} n
+ * @return {number[]|bigint[]}
+ */
+const build = ({zero, one, iadd}, n) => {
+	const g = gen(iadd, zero(), one());
+	return Array.from(takewhile(le(n), g));
+};
+
+export default build;

src/gen.js

@@ -0,0 +1,18 @@
+/**
+ * Gen.
+ *
+ * @param {Function} iadd
+ * @param {number|bigint} a
+ * @param {number|bigint} b
+ * @return {IterableIterator<number>|IterableIterator<bigint>}
+ */
+const gen = function* (iadd, a, b) {
+	yield a;
+	yield b;
+	while (true) {
+		yield (a = iadd(b, a));
+		yield (b = iadd(a, b));
+	}
+};
+
+export default gen;

src/index.js

@@ -1,2 +1,3 @@
-const answer = 42;
-export default answer;
+export {default as build} from './build.js';
+export {default as gen} from './gen.js';
+export {default as query} from './query.js';

src/query.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert';
+import build from './build.js';
+
+/**
+ * Query ϕ[i].
+ *
+ * @param {Object} type
+ * @param {number[]|bigint[]} array
+ * @param {number|bigint} i
+ * @return {number|bigint}
+ */
+const query = (type, array, i) => {
+	assert(typeof i === 'bigint' || (Number.isInteger(i) && i >= 0));
+	assert(typeof i !== 'bigint' || i >= 0n);
+	assert(array || type);
+	const F = array ?? build(type, i);
+	let n_1 = F.length - 1;
+	const zero = n_1 === -1 ? i : F[0] - F[0];
+	assert(array || i === zero || i >= F[n_1]);
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		assert(i >= zero);
+		assert(array || n_1 + 1 === F.length);
+		if (n_1 <= 0) return i;
+		assert(n_1 + 1 >= 2);
+		assert(i < F[n_1] + F[n_1 - 1]); // Equivalent to i < F[n] = F[n_1 + 1]
+		if (i >= F[n_1]) {
+			i -= F[n_1];
+			--n_1;
+			if (F !== array) F.pop();
+		}
+
+		if (F !== array) F.pop();
+		--n_1;
+	}
+};
+
+export default query;

test/src/_fixtures.js

@@ -0,0 +1,67 @@
+import assert from 'node:assert';
+
+import {nth} from '@iterable-iterator/select';
+import {list} from '@iterable-iterator/list';
+import {map} from '@iterable-iterator/map';
+import {range} from '@iterable-iterator/range';
+import {take} from '@iterable-iterator/slice';
+
+import {query, gen} from '../../src/index.js';
+
+// eslint-disable-next-line no-return-assign
+export const iadd = (a, b) => (a += b);
+export const zero = () => 1;
+export const one = () => 2;
+export const type = {zero, one, iadd};
+
+export const zeron = () => 1n;
+export const onen = () => 2n;
+export const typen = {zero: zeron, one: onen, iadd};
+
+export const repr = (x) => {
+	const s = typeof x === 'bigint' ? `${x}n` : JSON.stringify(x);
+	if (s.length <= 40) return s;
+	return s.slice(0, 19) + '..' + s.slice(-19);
+};
+
+const concat = (a, b) => a.concat(b);
+export const string = (x, y) => (n) => nth(gen(concat, y, x), n - 1);
+
+export const gs = function* ({a, b}, n) {
+	if (n === 0) return;
+	if (n === 1) {
+		for (let i = 0; i < b.length; ++i) {
+			yield a.length + i;
+		}
+
+		return;
+	}
+
+	const F = Array.from(take(gen(iadd, a.length, a.length + b.length), n - 1));
+	const Fn = F.pop();
+	for (const i of range(Fn)) yield query(undefined, F, i);
+};
+
+export const makeSymbol = ({a, b}) => {
+	const m = a.length;
+	const n = b.length;
+	const number = (i) => {
+		assert(i >= 0);
+		assert(i <= m + n);
+		return i < m ? a[i] : b[i - m];
+	};
+
+	const mn = BigInt(m);
+	const nn = BigInt(n);
+	const bigint = (_in) => {
+		assert(_in >= 0n);
+		assert(_in <= mn + nn);
+		const i = Number(_in);
+		return i < m ? a[i] : b[i - m];
+	};
+
+	return (x) => (typeof x === 'bigint' ? bigint(x) : number(x));
+};
+
+export const fs = (alphabet, n) =>
+	list(map(makeSymbol(alphabet), gs(alphabet, n))).join('');

test/src/api.js

@@ -0,0 +1,24 @@
+import test from 'ava';
+
+import {enumerate} from '@iterable-iterator/zip';
+
+import {query} from '../../src/index.js';
+
+import {makeSymbol, type, typen, repr} from './_fixtures.js';
+
+const symbol = makeSymbol({a: 'a', b: 'b'});
+
+const macro = (t, type, i, expected) => {
+	t.is(symbol(query(type, undefined, i)), expected);
+};
+
+macro.title = (title, _, i, expected) =>
+	title ?? `query(${repr(i)}) is ${repr(expected)}`;
+
+const phi10 = 'abaababaabaababaababaabaababaabaababaababaabaababaababa';
+const input = phi10;
+
+for (const [i, x] of enumerate(input)) {
+	test(macro, type, i, x);
+	test(macro, typen, BigInt(i), x);
+}

test/src/query.js

@@ -0,0 +1,45 @@
+import test from 'ava';
+
+import {fs, string, repr} from './_fixtures.js';
+
+const macro = (t, alphabet, n, expected) => {
+	t.is(fs(alphabet, n), expected);
+};
+
+macro.title = (title, alphabet, n, expected) =>
+	title ?? `[${repr(alphabet)}] fs(${n}) is ${repr(expected)}`;
+
+const expected = ({a, b}, n) => string(a, b)(n);
+
+const auto = (t, alphabet, n) => {
+	return macro(t, alphabet, n, expected(alphabet, n));
+};
+
+auto.title = (title, alphabet, n) =>
+	macro.title(title, alphabet, n, expected(alphabet, n));
+
+const ab = {a: 'a', b: 'b'};
+
+const alphabets = [
+	ab,
+	{a: 'x', b: 'y'},
+	{a: 'ii', b: 'oo'},
+	{a: 'abra', b: 'cadabra'},
+];
+
+test(macro, ab, 0, '');
+test(macro, ab, 1, 'b');
+test(macro, ab, 2, 'a');
+test(macro, ab, 3, 'ab');
+test(macro, ab, 4, 'aba');
+test(macro, ab, 5, 'abaab');
+test(macro, ab, 6, 'abaababa');
+test(macro, ab, 7, 'abaababaabaab');
+test(macro, ab, 8, 'abaababaabaababaababa');
+test(macro, ab, 9, 'abaababaabaababaababaabaababaabaab');
+test(macro, ab, 10, 'abaababaabaababaababaabaababaabaababaababaabaababaababa');
+
+for (const alphabet of alphabets) {
+	test(auto, alphabet, 15);
+	test(auto, alphabet, 20);
+}