@bian-womp/spark-graph 0.1.24 → 0.1.25

package/lib/cjs/index.cjs

@@ -1992,6 +1992,16 @@ function setupBasicGraphRegistry() {
             { value: 13, label: "Avg" },
             { value: 14, label: "MinAll" },
             { value: 15, label: "MaxAll" },
+            // Trig and other unary functions on A
+            { value: 16, label: "Sin" },
+            { value: 17, label: "Cos" },
+            { value: 18, label: "Tan" },
+            { value: 19, label: "ASin" },
+            { value: 20, label: "ACos" },
+            { value: 21, label: "ATan" },
+            { value: 22, label: "Sqrt" },
+            { value: 23, label: "Exp" },
+            { value: 24, label: "Log" },
         ],
     });
     // Enums: Compare Operation
@@ -2134,30 +2144,35 @@ function setupBasicGraphRegistry() {
             const b = ins.B === undefined ? [] : asArray(ins.B);
             const op = Number(ins.Operation ?? 0) | 0;
             // Unary ops on A
-            if (op === 8)
-                return { Result: a.map((x) => Math.round(Number(x))) };
-            if (op === 9)
-                return { Result: a.map((x) => Math.floor(Number(x))) };
-            if (op === 10)
-                return { Result: a.map((x) => Math.ceil(Number(x))) };
-            if (op === 11)
-                return { Result: a.map((x) => Math.abs(Number(x))) };
+            const unary = {
+                8: (x) => Math.round(x),
+                9: (x) => Math.floor(x),
+                10: (x) => Math.ceil(x),
+                11: (x) => Math.abs(x),
+                16: (x) => Math.sin(x),
+                17: (x) => Math.cos(x),
+                18: (x) => Math.tan(x),
+                19: (x) => Math.asin(x),
+                20: (x) => Math.acos(x),
+                21: (x) => Math.atan(x),
+                22: (x) => Math.sqrt(x),
+                23: (x) => Math.exp(x),
+                24: (x) => Math.log(x),
+            };
+            if (op in unary)
+                return { Result: a.map((x) => unary[op](Number(x))) };
             // Aggregate ops on A -> single-element array
-            if (op === 12)
-                return { Result: [a.reduce((s, x) => s + Number(x || 0), 0)] };
-            if (op === 13) {
-                const sum = a.reduce((s, x) => s + Number(x || 0), 0);
-                const avg = a.length ? sum / a.length : 0;
-                return { Result: [avg] };
-            }
-            if (op === 14)
-                return {
-                    Result: [a.length ? Math.min(...a.map((x) => Number(x))) : 0],
-                };
-            if (op === 15)
-                return {
-                    Result: [a.length ? Math.max(...a.map((x) => Number(x))) : 0],
-                };
+            const aggregates = {
+                12: (arr) => arr.reduce((s, x) => s + Number(x || 0), 0),
+                13: (arr) => {
+                    const sum = arr.reduce((s, x) => s + Number(x || 0), 0);
+                    return arr.length ? sum / arr.length : 0;
+                },
+                14: (arr) => (arr.length ? Math.min(...arr.map((x) => Number(x))) : 0),
+                15: (arr) => (arr.length ? Math.max(...arr.map((x) => Number(x))) : 0),
+            };
+            if (op in aggregates)
+                return { Result: [aggregates[op](a)] };
             // Binary ops A (broadcast) B
             const len = Math.max(a.length, b.length);
             const ops = [