functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/types/array/proof.f.js

@@ -1,117 +1,85 @@
-import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
+import { at, first, last, head, tail, splitFirst, splitLast, empty } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { assertEq, assertNotNullish } from '../../asserts/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     stringify: () => {
         const result = stringify([1, 20, 300]);
-        if (result !== '[1,20,300]') {
-            throw result;
-        }
+        assertEq(result, '[1,20,300]');
     },
     at: [
         () => {
             const result = at(2)([1, 20, 300]);
-            if (result !== 300) {
-                throw result;
-            }
+            assertEq(result, 300);
         },
         () => {
             const result = at(3)([1, 20, 300]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     first: [
         () => {
             const result = first([1, 20, 300]);
-            if (result !== 1) {
-                throw result;
-            }
+            assertEq(result, 1);
         },
         () => {
             const result = first([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     last: [
         () => {
             const result = last([1, 20, 300]);
-            if (result !== 300) {
-                throw result;
-            }
+            assertEq(result, 300);
         },
         () => {
             const result = last([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     head: [
         () => {
-            const result = head([1, 20, 300]);
-            if (result === null) {
-                throw result;
-            }
+            const result = assertNotNullish(head([1, 20, 300]));
             const str = stringify(result);
-            if (str !== '[1,20]') {
-                throw str;
-            }
+            assertEq(str, '[1,20]');
         },
         () => {
             const result = head([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     tail: [
         () => {
             const result = tail([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[20,300]') {
-                throw str;
-            }
+            assertEq(str, '[20,300]');
         },
         () => {
             const result = tail([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     splitFirst: [
         () => {
             const result = splitFirst([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[1,[20,300]]') {
-                throw str;
-            }
+            assertEq(str, '[1,[20,300]]');
         },
         () => {
             const result = splitFirst([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         },
     ],
     splitLast: [
         () => {
             const result = splitLast([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[[1,20],300]') {
-                throw str;
-            }
+            assertEq(str, '[[1,20],300]');
         },
         () => {
             const result = splitLast([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     empty: () => {
@@ -119,8 +87,6 @@ export const proof = {
         const a = x;
         const b = x;
         const c = [...a, ...b, ...x];
-        if (c.length !== 0) {
-            throw c;
-        }
+        assertEq(c.length, 0, c);
     }
 };

package/{fs → fjs}/types/bigfloat/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { abs, sign } from "../bigint/module.f.js";
+import { abs, sign } from '../bigint/module.f.js';
 const twoPow53 = 9007199254740992n;
 const twoPow54 = 18014398509481984n;
 /**

package/fjs/types/bigfloat/proof.f.js

@@ -0,0 +1,217 @@
+import { decToBin } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    decToBin: [
+        () => {
+            const result = decToBin([0n, 0]);
+            assertEq(result[0], 0n, result[0].toString(2));
+            assertEq(result[1], 0);
+        },
+        () => {
+            const result = decToBin([0n, 10]);
+            assertEq(result[0], 0n, result[0].toString(2));
+            assertEq(result[1], 0);
+        },
+        () => {
+            const result = decToBin([0n, -10]);
+            assertEq(result[0], 0n, result[0].toString(2));
+            assertEq(result[1], 0);
+        },
+        () => {
+            const result = decToBin([1n, 0]);
+            assertEq(result[0], 4503599627370496n, result[0].toString(2));
+            assertEq(result[1], -52);
+        },
+        () => {
+            const result = decToBin([1n, 1]);
+            assertEq(result[0], 5629499534213120n, result[0].toString(2));
+            assertEq(result[1], -49);
+        },
+        () => {
+            const result = decToBin([1000n, -2]);
+            assertEq(result[0], 5629499534213120n, result[0].toString(2));
+            assertEq(result[1], -49);
+        },
+        () => {
+            const result = decToBin([1n, -1]);
+            assertEq(result[0], 7205759403792794n, result[0].toString(2)); //+1
+            assertEq(result[1], -56);
+        },
+        () => {
+            const result = decToBin([-1n, 0]);
+            assertEq(result[0], -4503599627370496n, result[0].toString(2));
+            assertEq(result[1], -52);
+        },
+        () => {
+            const result = decToBin([-1n, 1]);
+            assertEq(result[0], -5629499534213120n, result[0].toString(2));
+            assertEq(result[1], -49);
+        },
+        () => {
+            const result = decToBin([-1000n, -2]);
+            assertEq(result[0], -5629499534213120n, result[0].toString(2));
+            assertEq(result[1], -49);
+        },
+        () => {
+            const result = decToBin([-1n, -1]);
+            assertEq(result[0], -7205759403792794n, result[0].toString(2)); //+1
+            assertEq(result[1], -56);
+        },
+        () => {
+            const result = decToBin([9007199254740993n, 0]); //54bits (...0.1)
+            assertEq(result[0], 4503599627370496n, result[0].toString(2));
+            assertEq(result[1], 1);
+        },
+        () => {
+            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
+            assertEq(result[0], -4503599627370498n, result[0].toString(2));
+            assertEq(result[1], 1);
+        },
+        () => {
+            const result = decToBin([-9007199254740993n, 0]); //54bits (...0.1)
+            assertEq(result[0], -4503599627370496n, result[0].toString(2));
+            assertEq(result[1], 1);
+        },
+        () => {
+            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
+            assertEq(result[0], -4503599627370498n, result[0].toString(2));
+            assertEq(result[1], 1);
+        },
+        () => {
+            const result = decToBin([18014398509481985n, 0]); //55bits (...0.01)
+            assertEq(result[0], 4503599627370496n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([18014398509481986n, 0]); //55bits (...0.10)
+            assertEq(result[0], 4503599627370496n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([18014398509481990n, 0]); //55bits (...1.10)
+            assertEq(result[0], 4503599627370498n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([18014398509481987n, 0]); //55bits (0.11)
+            assertEq(result[0], 4503599627370497n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+    ],
+    roundingPositive: [
+        () => {
+            const result = decToBin([288230376151711745n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011001.101
+            // rounding up
+            assertEq(result[0], 7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711760n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.000
+            // rounding down
+            assertEq(result[0], 7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711780n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding down (to even)
+            assertEq(result[0], 7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711781n, -1]);
+            // reminder = 1
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding up
+            assertEq(result[0], 7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711785n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.101
+            // rounding up
+            assertEq(result[0], 7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711805n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.001
+            // rounding down
+            assertEq(result[0], 7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([288230376151711820n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.100
+            // rounding up (to even)
+            assertEq(result[0], 7205759403792796n, result[0].toString(2));
+            assertEq(result[1], 2);
+        }
+    ],
+    roundingNegative: [
+        () => {
+            const result = decToBin([-288230376151711745n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011001.101
+            // rounding down
+            assertEq(result[0], -7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711760n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.000
+            // rounding up
+            assertEq(result[0], -7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711780n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding up (to even)
+            assertEq(result[0], -7205759403792794n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711781n, -1]);
+            // reminder = 1
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding down
+            assertEq(result[0], -7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711785n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.101
+            // rounding down
+            assertEq(result[0], -7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711805n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.001
+            // rounding up
+            assertEq(result[0], -7205759403792795n, result[0].toString(2));
+            assertEq(result[1], 2);
+        },
+        () => {
+            const result = decToBin([-288230376151711820n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.100
+            // rounding down (to even)
+            assertEq(result[0], -7205759403792796n, result[0].toString(2));
+            assertEq(result[1], 2);
+        }
+    ]
+};

package/{fs → fjs}/types/bigint/module.f.js

@@ -16,8 +16,8 @@
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
-import { cmp } from "../function/compare/module.f.js";
-import { reduce } from "../list/module.f.js";
+import { cmp } from '../function/compare/module.f.js';
+import { reduce } from '../list/module.f.js';
 /**
  * Adds two `bigint` values.
  *