@mojir/lits 2.1.10 → 2.1.12

package/dist/lits.iife.js

@@ -698,7 +698,7 @@ var Lits = (function (exports) {
         if (a === b)
             return true;
         if (typeof a === 'number' && typeof b === 'number')
-            return Math.abs(a - b) < 1e-10;
+            return approxEqual(a, b);
         if (Array.isArray(a) && Array.isArray(b)) {
             if (a.length !== b.length)
                 return false;
@@ -798,9 +798,8 @@ var Lits = (function (exports) {
         // Use relative error for larger values
         return diff / (absA + absB) < epsilon;
     }
-    function approxZero(value, epsilon) {
-        if (epsilon === void 0) { epsilon = EPSILON; }
-        return Math.abs(value) < epsilon;
+    function approxZero(value) {
+        return Math.abs(value) < EPSILON;
     }
 
     // isArray not needed, use Array.isArary
@@ -2561,30 +2560,6 @@ var Lits = (function (exports) {
             },
             paramCount: {},
         },
-        '~': {
-            evaluate: function (params, sourceCodeInfo) {
-                var _a;
-                var _b = __read(getNumberVectorOrMatrixOperation([params[0], params[1]], sourceCodeInfo), 2), operation = _b[0], operands = _b[1];
-                var eplsilon = (_a = params[2]) !== null && _a !== void 0 ? _a : 1e-10;
-                assertNumber(eplsilon, sourceCodeInfo, { positive: true, finite: true });
-                if (operation === 'number') {
-                    var _c = __read(operands, 2), first = _c[0], second = _c[1];
-                    return approxEqual(first, second, eplsilon);
-                }
-                else if (operation === 'vector') {
-                    var firstVector = operands[0];
-                    var secondVector_1 = operands[1];
-                    return firstVector.every(function (val, i) { return approxEqual(val, secondVector_1[i], eplsilon); });
-                }
-                else {
-                    var firstMatrix = operands[0];
-                    var secondMatrix_1 = operands[1];
-                    return firstMatrix.every(function (row, i) { return row.every(function (val, j) { return approxEqual(val, secondMatrix_1[i][j], eplsilon); }); });
-                }
-            },
-            paramCount: { min: 2, max: 3 },
-            aliases: ['≈'],
-        },
         'quot': {
             evaluate: function (params, sourceCodeInfo) {
                 var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
@@ -2593,13 +2568,13 @@ var Lits = (function (exports) {
                 }
                 else if (operation === 'vector') {
                     var firstVector = operands[0];
-                    var secondVector_2 = operands[1];
-                    return firstVector.map(function (val, i) { return Math.trunc(val / secondVector_2[i]); });
+                    var secondVector_1 = operands[1];
+                    return firstVector.map(function (val, i) { return Math.trunc(val / secondVector_1[i]); });
                 }
                 else {
                     var firstMatrix = operands[0];
-                    var secondMatrix_2 = operands[1];
-                    return firstMatrix.map(function (row, i) { return row.map(function (val, j) { return Math.trunc(val / secondMatrix_2[i][j]); }); });
+                    var secondMatrix_1 = operands[1];
+                    return firstMatrix.map(function (row, i) { return row.map(function (val, j) { return Math.trunc(val / secondMatrix_1[i][j]); }); });
                 }
             },
             paramCount: 2,
@@ -2613,19 +2588,19 @@ var Lits = (function (exports) {
                 }
                 else if (operation === 'vector') {
                     var firstVector = operands[0];
-                    var secondVector_3 = operands[1];
+                    var secondVector_2 = operands[1];
                     return firstVector.map(function (dividend, i) {
-                        var divisor = secondVector_3[i];
+                        var divisor = secondVector_2[i];
                         var quotient = Math.floor(dividend / divisor);
                         return dividend - divisor * quotient;
                     });
                 }
                 else {
                     var firstMatrix = operands[0];
-                    var secondMatrix_3 = operands[1];
+                    var secondMatrix_2 = operands[1];
                     return firstMatrix.map(function (row, i) { return row.map(function (val, j) {
-                        var quotient = Math.floor(val / secondMatrix_3[i][j]);
-                        return val - secondMatrix_3[i][j] * quotient;
+                        var quotient = Math.floor(val / secondMatrix_2[i][j]);
+                        return val - secondMatrix_2[i][j] * quotient;
                     }); });
                 }
             },
@@ -2639,13 +2614,13 @@ var Lits = (function (exports) {
                 }
                 else if (operation === 'vector') {
                     var firstVector = operands[0];
-                    var secondVector_4 = operands[1];
-                    return firstVector.map(function (dividend, i) { return dividend % secondVector_4[i]; });
+                    var secondVector_3 = operands[1];
+                    return firstVector.map(function (dividend, i) { return dividend % secondVector_3[i]; });
                 }
                 else {
                     var firstMatrix = operands[0];
-                    var secondMatrix_4 = operands[1];
-                    return firstMatrix.map(function (row, i) { return row.map(function (dividend, j) { return dividend % secondMatrix_4[i][j]; }); });
+                    var secondMatrix_3 = operands[1];
+                    return firstMatrix.map(function (row, i) { return row.map(function (dividend, j) { return dividend % secondMatrix_3[i][j]; }); });
                 }
             },
             paramCount: 2,
@@ -2695,13 +2670,13 @@ var Lits = (function (exports) {
                 }
                 else if (operation === 'vector') {
                     var firstVector = operands[0];
-                    var secondVector_5 = operands[1];
-                    return firstVector.map(function (base, i) { return Math.pow(base, secondVector_5[i]); });
+                    var secondVector_4 = operands[1];
+                    return firstVector.map(function (base, i) { return Math.pow(base, secondVector_4[i]); });
                 }
                 else {
                     var firstMatrix = operands[0];
-                    var secondMatrix_5 = operands[1];
-                    return firstMatrix.map(function (row, i) { return row.map(function (base, j) { return Math.pow(base, secondMatrix_5[i][j]); }); });
+                    var secondMatrix_4 = operands[1];
+                    return firstMatrix.map(function (row, i) { return row.map(function (base, j) { return Math.pow(base, secondMatrix_4[i][j]); }); });
                 }
             },
             paramCount: 2,
@@ -3113,6 +3088,40 @@ var Lits = (function (exports) {
             },
             paramCount: 1,
         },
+        'to-rad': {
+            evaluate: function (params, sourceCodeInfo) {
+                var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
+                if (operation === 'number') {
+                    return (operands[0] * Math.PI) / 180;
+                }
+                else if (operation === 'vector') {
+                    var vector = operands[0];
+                    return vector.map(function (val) { return (val * Math.PI) / 180; });
+                }
+                else {
+                    var matrix = operands[0];
+                    return matrix.map(function (row) { return row.map(function (val) { return (val * Math.PI) / 180; }); });
+                }
+            },
+            paramCount: 1,
+        },
+        'to-deg': {
+            evaluate: function (params, sourceCodeInfo) {
+                var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
+                if (operation === 'number') {
+                    return (operands[0] * 180) / Math.PI;
+                }
+                else if (operation === 'vector') {
+                    var vector = operands[0];
+                    return vector.map(function (val) { return (val * 180) / Math.PI; });
+                }
+                else {
+                    var matrix = operands[0];
+                    return matrix.map(function (row) { return row.map(function (val) { return (val * 180) / Math.PI; }); });
+                }
+            },
+            paramCount: 1,
+        },
     };
 
     function isEqual(_a, sourceCodeInfo) {
@@ -3732,9 +3741,9 @@ var Lits = (function (exports) {
         },
         'zero?': {
             evaluate: function (_a, sourceCodeInfo) {
-                var _b = __read(_a, 1), first = _b[0];
-                assertNumber(first, sourceCodeInfo, { finite: true });
-                return first === 0;
+                var _b = __read(_a, 1), value = _b[0];
+                assertNumber(value, sourceCodeInfo, { finite: true });
+                return Math.abs(value) < EPSILON;
             },
             paramCount: 1,
         },
@@ -6580,6 +6589,10 @@ var Lits = (function (exports) {
         return vector.map(function (item) { return item * scalar; });
     }
 
+    function length(vector) {
+        return Math.sqrt(vector.reduce(function (acc, item) { return acc + Math.pow(item, 2); }, 0));
+    }
+
     var linearAlgebraNormalExpression = {
         'lin:rotate2d': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -6904,7 +6917,7 @@ var Lits = (function (exports) {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), vector = _b[0];
                 assertNonEmptyVector(vector, sourceCodeInfo);
-                return Math.sqrt(vector.reduce(function (acc, val) { return acc + val * val; }, 0));
+                return length(vector);
             },
             paramCount: 1,
             aliases: ['lin:l2-norm', 'lin:length'],
@@ -7210,6 +7223,31 @@ var Lits = (function (exports) {
             },
             paramCount: 2,
         },
+        'lin:to-polar': {
+            evaluate: function (_a, sourceCodeInfo) {
+                var _b = __read(_a, 1), vector = _b[0];
+                assert2dVector(vector, sourceCodeInfo);
+                if (isZeroVector(vector)) {
+                    return [0, 0];
+                }
+                var r = Math.sqrt(Math.pow(vector[0], 2) + Math.pow(vector[1], 2));
+                var theta = Math.atan2(vector[1], vector[0]);
+                return [r, theta];
+            },
+            paramCount: 1,
+        },
+        'lin:from-polar': {
+            evaluate: function (_a, sourceCodeInfo) {
+                var _b = __read(_a, 1), polar = _b[0];
+                assert2dVector(polar, sourceCodeInfo);
+                var _c = __read(polar, 2), r = _c[0], theta = _c[1];
+                if (r === 0) {
+                    return [0, 0];
+                }
+                return [r * Math.cos(theta), r * Math.sin(theta)];
+            },
+            paramCount: 1,
+        },
     };
 
     /**
@@ -12892,8 +12930,6 @@ var Lits = (function (exports) {
         '=', // equal
         '!=', // not equal
         '≠', // not equal
-        '~', // approximate
-        '≈', // approximate
         '&', // bitwise AND
         'xor', // bitwise XOR
         '|', // bitwise OR
@@ -12903,6 +12939,8 @@ var Lits = (function (exports) {
         '|>', // pipe
     ];
     var otherOperators = [
+        '?', // conditional operator
+        ':', // conditional operator
         '->', // lambda
         '...', // rest
         '.', // property accessor
@@ -12912,17 +12950,12 @@ var Lits = (function (exports) {
     ];
     var symbolicOperators = __spreadArray(__spreadArray([], __read(binaryOperators), false), __read(otherOperators), false);
     var nonFunctionOperators = [
-        '??',
-        '&&',
-        '||',
         'comment',
         'cond',
         'def',
         'defined?',
-        // 'defn',
         'do',
         'doseq',
-        // 'fn',
         'if',
         'let',
         'loop',
@@ -13500,8 +13533,9 @@ var Lits = (function (exports) {
         }, '');
     }
 
-    var exponentiationPrecedence = 11;
-    var binaryFunctionalOperatorPrecedence = 2;
+    var exponentiationPrecedence = 12;
+    var binaryFunctionalOperatorPrecedence = 3;
+    var conditionalOperatorPrecedence = 1;
     var placeholderRegexp = /^\$([1-9]\d?)?$/;
     function withSourceCodeInfo(node, sourceCodeInfo) {
         if (sourceCodeInfo) {
@@ -13516,40 +13550,39 @@ var Lits = (function (exports) {
             case '*': // multiplication
             case '/': // division
             case '%': // remainder
-                return 10;
+                return 11;
             case '+': // addition
             case '-': // subtraction
-                return 9;
+                return 10;
             case '<<': // left shift
             case '>>': // signed right shift
             case '>>>': // unsigned right shift
-                return 8;
+                return 9;
             case '++': // string concatenation
-                return 7;
+                return 8;
             case '<': // less than
             case '<=': // less than or equal
             case '≤': // less than or equal
             case '>': // greater than
             case '>=': // greater than or equal
             case '≥': // greater than or equal
-                return 6;
+                return 7;
             case '=': // equal
             case '!=': // not equal
             case '≠': // not equal
-            case '~': // approximate
-            case '≈': // approximate
-                return 5;
+                return 6;
             case '&': // bitwise AND
             case 'xor': // bitwise XOR
             case '|': // bitwise OR
-                return 4;
+                return 5;
             case '&&': // logical AND
             case '||': // logical OR
             case '??': // nullish coalescing
-                return 3;
+                return 4;
+            // leave room for binaryFunctionalOperatorPrecedence = 3
             case '|>': // pipe
-                return 1;
-            // leave room for binaryFunctionalOperatorPrecedence = 2
+                return 2;
+            // leave room for conditionalOperatorPrecedence = 1
             /* v8 ignore next 2 */
             default:
                 throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
@@ -13591,21 +13624,21 @@ var Lits = (function (exports) {
             case '&':
             case 'xor':
             case '|':
-            case '~':
-            case '≈':
             case '|>':
                 return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
             case '&&':
             case '||':
             case '??':
                 return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes[operatorName], [left, right]]], sourceCodeInfo);
-            /* v8 ignore next 10 */
+            /* v8 ignore next 11 */
             case '.':
             case ';':
             case ':=':
             case ',':
             case '->':
             case '...':
+            case '?':
+            case ':':
                 throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
             default:
                 throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
@@ -13721,6 +13754,19 @@ var Lits = (function (exports) {
                     }
                     left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
                 }
+                else if ((operator === null || operator === void 0 ? void 0 : operator[1]) === '?') {
+                    if (conditionalOperatorPrecedence <= precedence) {
+                        break;
+                    }
+                    this.advance();
+                    var trueNode = this.parseExpression();
+                    if (!isOperatorToken(this.peek(), ':')) {
+                        throw new LitsError('Expected :', this.peekSourceCodeInfo());
+                    }
+                    this.advance();
+                    var falseNode = this.parseExpression();
+                    left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
+                }
                 else {
                     break;
                 }
@@ -14978,7 +15024,6 @@ var Lits = (function (exports) {
             '-',
             '*',
             '/',
-            '~',
             'mod',
             'rem',
             'quot',
@@ -15010,6 +15055,8 @@ var Lits = (function (exports) {
             'asinh',
             'acosh',
             'atanh',
+            'to-rad',
+            'to-deg',
         ],
         functional: [
             '|>',
@@ -15282,6 +15329,8 @@ var Lits = (function (exports) {
             'lin:cross-correlation',
             'lin:rref',
             'lin:solve',
+            'lin:to-polar',
+            'lin:from-polar',
         ],
         numberTheory: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(getNumberTheorySequenceNames('abundant')), false), __read(getNumberTheorySequenceNames('bell')), false), __read(getNumberTheorySequenceNames('catalan')), false), __read(getNumberTheorySequenceNames('composite')), false), __read(getNumberTheorySequenceNames('factorial')), false), __read(getNumberTheorySequenceNames('fibonacci')), false), __read(getNumberTheorySequenceNames('geometric')), false), __read(getNumberTheorySequenceNames('golomb')), false), __read(getNumberTheorySequenceNames('happy')), false), __read(getNumberTheorySequenceNames('look-and-say')), false), __read(getNumberTheorySequenceNames('lucas')), false), __read(getNumberTheorySequenceNames('lucky')), false), __read(getNumberTheorySequenceNames('mersenne')), false), __read(getNumberTheorySequenceNames('padovan')), false), __read(getNumberTheorySequenceNames('partition')), false), __read(getNumberTheorySequenceNames('pell')), false), __read(getNumberTheorySequenceNames('perfect')), false), __read(getNumberTheorySequenceNames('perfect-cube')), false), __read(getNumberTheorySequenceNames('perfect-power')), false), __read(getNumberTheorySequenceNames('perfect-square')), false), __read(getNumberTheorySequenceNames('polygonal')), false), __read(getNumberTheorySequenceNames('prime')), false), __read(getNumberTheorySequenceNames('recaman')), false), __read(getNumberTheorySequenceNames('sylvester')), false), __read(getNumberTheorySequenceNames('thue-morse')), false), __read(getNumberTheorySequenceNames('tribonacci')), false), [
             'nth:collatz-seq',
@@ -16991,29 +17040,6 @@ var Lits = (function (exports) {
                 '[[1, 2, 3], [4, 5, 6]] / 2',
             ],
         },
-        '~': {
-            title: '~',
-            category: 'Math',
-            linkName: '-tilde',
-            returns: {
-                type: ['number', 'vector', 'matrix'],
-            },
-            args: __assign({}, mixedOperatorArgs),
-            variants: [
-                { argumentNames: ['a, b'] },
-            ],
-            description: 'The `~` checks for approximately equal values, returning `true` if the absolute difference between the two numbers is less than or equal to a small threshold (default: `1e-10`). It works on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it checks each element for approximate equality.',
-            examples: [
-                '~(0.1, 0.1)',
-                '~(0.1, 0.10000000000001)',
-                '~(0.1, 0.2)',
-                '~(0.1, 0.101, 0.1)',
-                '~([1, 2, 3], [1.00000000000001, 2.00000000000001, 3.00000000000001])',
-                '~([1, 2, 3], [1.1, 2.1, 3.1])',
-                '~([[1, 2, 3], [1, 2, 3]], [[1.01, 2.01, 3.01], [1.01, 2.01, 3.01]], 0.1)',
-            ],
-            aliases: ['≈'],
-        },
         'mod': {
             title: 'mod',
             category: 'Math',
@@ -17791,6 +17817,56 @@ var Lits = (function (exports) {
                 'atanh([[0.1, 0.2], [0.3, 0.4]])',
             ],
         },
+        'to-rad': {
+            title: 'to-rad',
+            category: 'Math',
+            linkName: 'to-rad',
+            returns: {
+                type: ['number', 'vector', 'matrix'],
+            },
+            args: {
+                x: {
+                    type: ['number', 'vector', 'matrix'],
+                },
+            },
+            variants: [
+                { argumentNames: ['x'] },
+            ],
+            description: 'The `to-rad` function converts an angle from degrees to radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
+            examples: [
+                'to-rad(0)',
+                'to-rad(90)',
+                'to-rad(180)',
+                'to-rad(360)',
+                'to-rad([0, 90, 180])',
+                'to-rad([[0, 90], [180, 360]])',
+            ],
+        },
+        'to-deg': {
+            title: 'to-deg',
+            category: 'Math',
+            linkName: 'to-deg',
+            returns: {
+                type: ['number', 'vector', 'matrix'],
+            },
+            args: {
+                x: {
+                    type: ['number', 'vector', 'matrix'],
+                },
+            },
+            variants: [
+                { argumentNames: ['x'] },
+            ],
+            description: 'The `to-deg` function converts an angle from radians to degrees, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
+            examples: [
+                'to-deg(0)',
+                'to-deg(PI)',
+                'to-deg(PI / 2)',
+                'to-deg(3 * PI / 2)',
+                'to-deg([0, PI, PI / 2])',
+                'to-deg([[0, PI], [PI / 2, 3 * PI / 2]])',
+            ],
+        },
     };
 
     var miscReference = {
@@ -24244,6 +24320,51 @@ var Lits = (function (exports) {
                 'lin:solve([[2, 3], [1, -1]], [8, 2])',
             ],
         },
+        'lin:to-polar': {
+            title: 'lin:to-polar',
+            category: 'Linear Algebra',
+            description: 'Converts a 2D vector to polar coordinates.',
+            linkName: 'lin-colon-to-polar',
+            returns: {
+                type: 'vector',
+            },
+            args: {
+                vector: {
+                    type: 'vector',
+                    description: '2D Vector to convert.',
+                },
+            },
+            variants: [
+                { argumentNames: ['vector'] },
+            ],
+            examples: [
+                'lin:to-polar([1, 2])',
+                'lin:to-polar([3, 4])',
+            ],
+        },
+        'lin:from-polar': {
+            title: 'lin:from-polar',
+            category: 'Linear Algebra',
+            description: 'Converts polar coordinates to a 2D vector.',
+            linkName: 'lin-colon-from-polar',
+            returns: {
+                type: 'vector',
+            },
+            args: {
+                polar: {
+                    type: 'vector',
+                    description: 'Polar coordinates to convert.',
+                },
+            },
+            variants: [
+                { argumentNames: ['polar'] },
+            ],
+            examples: [
+                'lin:from-polar([1, PI / 4])',
+                'lin:from-polar([1, 0])',
+                'lin:from-polar([1, -PI / 2])',
+            ],
+        },
     };
 
     var predicateReference = {