wenay-common 1.0.185 → 1.0.188

package/lib/Common/Decorator.d.ts

@@ -0,0 +1,8 @@
+export declare function Decorator<T extends (...arg: any[]) => any>(func: T, option?: {
+    parameters?: (...a: Parameters<T>) => any;
+    parametersModifier?: (...a: Parameters<T>) => Parameters<T>;
+    parametersAfter?: (...a: Parameters<T>) => any;
+    result?: (a: ReturnType<T>) => any;
+    resultModifier?: (a: ReturnType<T>) => ReturnType<T>;
+}): (...arg: Parameters<T>) => ReturnType<T>;
+export declare function Transformer<T extends (...arg: any[]) => any, R>(func: T, transformer: (a: [params: Parameters<T>, result: ReturnType<T>]) => R): (...arg: Parameters<T>) => R;

package/lib/Common/Decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decorator = Decorator;
+exports.Transformer = Transformer;
+function Decorator(func, option) {
+    return (...arg) => {
+        option?.parameters?.(...arg);
+        const r = func(...(option?.parametersModifier?.(...arg) ?? arg));
+        option?.parametersAfter?.(...arg);
+        option?.result?.(r);
+        return option?.resultModifier?.(r) ?? r;
+    };
+}
+function Transformer(func, transformer) {
+    return (...arg) => {
+        const r = func(...arg);
+        return transformer([arg, r]);
+    };
+}

package/lib/Common/Math.d.ts

@@ -9,20 +9,27 @@ export declare function CorrelationRollingByBuffer(data: tCorrelationByBuffer):
         corr: number;
         buffer?: tCorrBuffer;
     };
+    corr2(a1: number, a2: number, k1: any, k2: any): {
+        corr: number;
+        buffer?: tCorrBuffer;
+    };
 };
 type tCorrBuffer = {
     sum1: number;
     sum2: number;
+    step: number;
     pow1: number;
     pow2: number;
     last1: number;
     last2: number;
+    first1: number;
+    first2: number;
     mulSum: number;
 };
 export declare function CorrelationFunc(d1: number[], d2: number[], setting: {
-    rolling?: number;
+    rolling: number;
     endBar?: number;
-    buffer?: tCorrBuffer | null;
+    buffer: tCorrBuffer | null;
 }): {
     corr: number;
     buffer?: tCorrBuffer;

package/lib/Common/Math.js

@@ -4,8 +4,9 @@ exports.CorrelationRollingByBuffer = CorrelationRollingByBuffer;
 exports.CorrelationFunc = CorrelationFunc;
 function CorrelationRollingByBuffer(data) {
     let setting = { ...data };
+    let total = 0;
     const map = new Map();
-    const defBuf = () => ({ last1: 0, last2: 0, mulSum: 0, pow1: 0, pow2: 0, sum2: 0, sum1: 0 });
+    const defBuf = () => ({ last1: 0, last2: 0, mulSum: 0, pow1: 0, pow2: 0, sum2: 0, sum1: 0, step: 0, first1: 0, first2: 0, total });
     const getBuffer = (key1, key2) => {
         let a1 = map.get(key1);
         if (!a1)
@@ -15,17 +16,44 @@ function CorrelationRollingByBuffer(data) {
             a1.set(key2, a2 = defBuf());
         return a2;
     };
+    const map2 = new Map();
+    const getBuffer2 = (key1, key2) => {
+        let a1 = map2.get(key1);
+        if (!a1)
+            map2.set(key1, a1 = new Map());
+        let a2 = a1.get(key2);
+        if (!a2)
+            a1.set(key2, a2 = { ar1: [], ar2: [] });
+        return a2;
+    };
     let index = 0;
     const clear = () => {
         index = 0;
         map.clear();
     };
+    function checkSize(e) {
+        const a = e.length - setting.max;
+        if (a > 0)
+            e.slice(0, a);
+    }
     return ({
         init(data) { setting = { ...data }; },
         clear(data) { clear(); data && this.init(data); },
         corr(arr1, arr2, key1, key2) {
-            const buffer = setting.bufferOn ? getBuffer(key1 ?? arr1, key2 ?? arr2) : null;
-            return CorrelationFunc(arr1, arr2, { rolling: setting.max, buffer });
+            let [k1, k2] = [key1 ?? arr1, key2 ?? arr2];
+            const buffer = setting.bufferOn ? getBuffer(k1, k2) : null;
+            const a = CorrelationFunc(arr1, arr2, { rolling: setting.max, buffer });
+            return a;
+        },
+        corr2(a1, a2, k1, k2) {
+            const buffer = setting.bufferOn ? getBuffer(k1, k2) : null;
+            const l = getBuffer2(k1, k2);
+            l.ar1.push(a1);
+            l.ar2.push(a2);
+            checkSize(l.ar1);
+            checkSize(l.ar2);
+            const a = CorrelationFunc(l.ar1, l.ar2, { rolling: setting.max, buffer });
+            return a;
         }
     });
 }
@@ -39,9 +67,12 @@ function CorrelationFunc(d1, d2, setting) {
     const start = (rolling) ? (n - rolling > 0 ? n - rolling : 0) : 0;
     const end = n;
     const c = n - start;
+    let step = (setting.buffer?.step ?? 0);
+    if (rolling && step > rolling)
+        step = rolling;
     const buffer = setting.buffer;
     const [end1, end2] = [d1[end - 1], d2[end - 1]];
-    const [last1, last2] = [d1[start], d2[start]];
+    let [last1, last2] = [d1[start], d2[start]];
     let sum1, sum2, pow1, pow2, mulSum;
     if (buffer && 1) {
         sum1 = buffer.sum1 - buffer.last1 + end1;
@@ -49,6 +80,11 @@ function CorrelationFunc(d1, d2, setting) {
         pow1 = buffer.pow1 - pow(buffer.last1, 2) + pow(end1, 2);
         pow2 = buffer.pow2 - pow(buffer.last2, 2) + pow(end2, 2);
         mulSum = buffer.mulSum - (buffer.last1 * buffer.last2) + (end1 * end2);
+        if (buffer.step < setting.rolling) {
+            buffer.step++;
+            step++;
+            last1 = last2 = 0;
+        }
     }
     else {
         const add = (a, b) => a + b;
@@ -61,8 +97,8 @@ function CorrelationFunc(d1, d2, setting) {
     }
     if (isNaN(sum1) || !sum1 ||
         isNaN(sum2) || !sum2 ||
-        isNaN(last1) || !last1 ||
-        isNaN(last2) || !last2 ||
+        isNaN(last1) ||
+        isNaN(last2) ||
         isNaN(mulSum) || !mulSum ||
         isNaN(pow2) || !pow2 ||
         isNaN(pow1) || !pow1) {
@@ -70,7 +106,9 @@ function CorrelationFunc(d1, d2, setting) {
         (async () => { throw "nanCor"; })();
     }
     const dense = sqrt((pow1 - pow(sum1, 2) / c) * (pow2 - pow(sum2, 2) / c));
-    const buf = { sum1, sum2, last1, last2, mulSum, pow2, pow1 };
+    const buf = { sum1, sum2, last1, last2, mulSum, pow2, pow1, step, first2: 0, first1: 0 };
+    if (buffer)
+        Object.assign(buffer, buf);
     if (dense == 0)
         return { corr: 0 };
     const result = (mulSum - (sum1 * sum2 / c)) / dense;

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./Common/node_console";
+export * from "./Common/Decorator";
 export * from "./Common/BaseTypes";
 export * from "./Common/ByteStream";
 export * from "./Common/Color";

package/lib/index.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadCandles = exports.Params = exports.List = exports.Math = exports.ListNodeAnd = exports.Color = exports.Time = exports.Common = exports.BaseTypes = void 0;
 exports.test = test;
 __exportStar(require("./Common/node_console"), exports);
+__exportStar(require("./Common/Decorator"), exports);
 __exportStar(require("./Common/BaseTypes"), exports);
 __exportStar(require("./Common/ByteStream"), exports);
 __exportStar(require("./Common/Color"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.185",
+  "version": "1.0.188",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",