ohlcv-indicators 3.5.80 → 3.5.82

package/src/moving-averages/heikenAshi.js

@@ -1,59 +1,53 @@
 import { FasterEMA } from '../core-indicators/index.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
-
+import { mathLog } from '../utilities/math.js';
 const isBadNumber = v => v == null || !Number.isFinite(v);
+const arithmeticReturn = (next, prev) => (next - prev) / prev;
+
 
 export const heikenAshi = (
   main,
   index,
   smoothLength,
   afterSmoothLength,
-  { lag = 0, bothNull = false, retLogs = true } = {}
+  { lag = 0, noSmoothing = false, retLogs = false } = {}
 ) => {
   const { verticalOhlcv, instances, scaledGroups } = main;
-  const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
-
-  const getRet = (next, prev) => retLogs
-    ? Math.log(next / prev)
-    : (next - prev) / prev;
-
-  const prefix = retLogs ? 'ret_log_' : 'ret_';
-
-  const paramsKey = bothNull ? '' : `_${indicatorKey}`;
-
-  const getKey = key => `${prefix}heiken_ashi_${key}${paramsKey}`;
-
-  const crossKey = bothNull
-    ? 'heiken_ashi_cross'
-    : `heiken_ashi_cross_${indicatorKey}`;
-
-  const instanceKey = bothNull
+  const instanceKey = noSmoothing
     ? 'heiken_ashi'
-    : `heiken_ashi_${indicatorKey}`;
+    : `heiken_ashi_${smoothLength}_${afterSmoothLength}`;
 
   // ---- INIT ----
   if (index === 0) {
     validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'heikenAshi');
     const ohlcKeys = ['open', 'high', 'low', 'close'];
     const featureKeys = ['body', 'upper_wick', 'lower_wick', 'range'];
+    const paramsKey = noSmoothing ? '' : `_${smoothLength}_${afterSmoothLength}`;
+    const prefix = retLogs ? 'ret_log_' : 'ret_';
+    const outputKeys = Object.fromEntries(
+      featureKeys.map(key => [key, `${prefix}heiken_ashi_${key}${paramsKey}`])
+    );
+    const crossKey = `heiken_ashi_cross${paramsKey}`;
+    const keyNames = Object.values(outputKeys);
 
     instances[instanceKey] = {
-      emaPre: !bothNull
+      emaPre: !noSmoothing
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(smoothLength)]))
         : null,
-      emaPost: !bothNull
+      emaPost: !noSmoothing
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(afterSmoothLength)]))
         : null,
       prevHaOpen: NaN,
       prevHaClose: NaN,
       prevSmOpen: NaN,
       prevSmClose: NaN,
-      isTrendUp: false,
+      trendDirection: 0,
+      getRet: retLogs ? mathLog : arithmeticReturn,
+      outputKeys,
+      crossKey
     };
 
-    const keyNames = featureKeys.map(getKey);
-
     initializeColumns(main, [...keyNames, crossKey].map(key => ({ key })), { lag });
 
     if (scaledGroups) {
@@ -67,6 +61,7 @@ export const heikenAshi = (
   const low = verticalOhlcv.low[index];
   const close = verticalOhlcv.close[index];
   const inst = instances[instanceKey];
+  const { crossKey, emaPre, emaPost, getRet, outputKeys } = inst;
 
   if (
     isBadNumber(open) ||
@@ -79,19 +74,19 @@ export const heikenAshi = (
 
   let sOpen, sHigh, sLow, sClose;
 
-  if (!bothNull) {
+  if (emaPre !== null) {
     // ---- PRE-SMOOTHING EMA ----
-    inst.emaPre.open.update(open);
-    inst.emaPre.high.update(high);
-    inst.emaPre.low.update(low);
-    inst.emaPre.close.update(close);
-
-    if (!inst.emaPre.open.isStable || !inst.emaPre.high.isStable ||
-        !inst.emaPre.low.isStable || !inst.emaPre.close.isStable) return;
-    sOpen = inst.emaPre.open.getResult();
-    sHigh = inst.emaPre.high.getResult();
-    sLow = inst.emaPre.low.getResult();
-    sClose = inst.emaPre.close.getResult();
+    emaPre.open.update(open);
+    emaPre.high.update(high);
+    emaPre.low.update(low);
+    emaPre.close.update(close);
+
+    if (!emaPre.open.isStable || !emaPre.high.isStable ||
+        !emaPre.low.isStable || !emaPre.close.isStable) return;
+    sOpen = emaPre.open.getResult();
+    sHigh = emaPre.high.getResult();
+    sLow = emaPre.low.getResult();
+    sClose = emaPre.close.getResult();
   } else {
     sOpen = open;
     sHigh = high;
@@ -126,19 +121,19 @@ export const heikenAshi = (
 
   let smOpen, smHigh, smLow, smClose;
 
-  if (!bothNull) {
+  if (emaPost !== null) {
     // ---- POST-SMOOTHING EMA ----
-    inst.emaPost.open.update(haOpen);
-    inst.emaPost.high.update(haHigh);
-    inst.emaPost.low.update(haLow);
-    inst.emaPost.close.update(haClose);
-
-    if (!inst.emaPost.open.isStable || !inst.emaPost.high.isStable ||
-        !inst.emaPost.low.isStable || !inst.emaPost.close.isStable) return;
-    smOpen = inst.emaPost.open.getResult();
-    smHigh = inst.emaPost.high.getResult();
-    smLow = inst.emaPost.low.getResult();
-    smClose = inst.emaPost.close.getResult();
+    emaPost.open.update(haOpen);
+    emaPost.high.update(haHigh);
+    emaPost.low.update(haLow);
+    emaPost.close.update(haClose);
+
+    if (!emaPost.open.isStable || !emaPost.high.isStable ||
+        !emaPost.low.isStable || !emaPost.close.isStable) return;
+    smOpen = emaPost.open.getResult();
+    smHigh = emaPost.high.getResult();
+    smLow = emaPost.low.getResult();
+    smClose = emaPost.close.getResult();
   } else {
     smOpen = haOpen;
     smHigh = haHigh;
@@ -161,40 +156,35 @@ export const heikenAshi = (
 
   // ---- TREND/CROSS LOGIC ----
   // Cross uses raw smoothed HA values, not the returned log/return features.
-  const prevCross = index > 0 ? verticalOhlcv[crossKey][index - 1] : 0;
-  const prevSmOpen = inst.prevSmOpen;
-  const prevSmClose = inst.prevSmClose;
-
-  const crossUp = (
-    Number.isFinite(prevSmOpen) &&
-    Number.isFinite(prevSmClose) &&
-    prevSmClose <= prevSmOpen &&
-    smClose > smOpen
-  );
-
-  const crossDown = (
-    Number.isFinite(prevSmOpen) &&
-    Number.isFinite(prevSmClose) &&
-    prevSmClose >= prevSmOpen &&
-    smClose < smOpen
-  );
-
-  if (crossUp) inst.isTrendUp = true;
-  if (crossDown) inst.isTrendUp = false;
-
-  let cross = 0;
-
-  if (index > 0) {
-    if (inst.isTrendUp) {
-      cross = prevCross > 0 ? prevCross + 1 : 1;
-    } else {
-      cross = prevCross < 0 ? prevCross - 1 : -1;
-    }
+  const hasPrevious = (
+    Number.isFinite(inst.prevSmOpen) &&
+    Number.isFinite(inst.prevSmClose)
+  )
+
+  const prevCross = index > 0
+    ? verticalOhlcv[crossKey][index - 1]
+    : NaN
+
+  // A doji preserves the established direction.
+  // Before any direction exists, it remains neutral.
+  const direction = smClose > smOpen
+    ? 1
+    : smClose < smOpen
+      ? -1
+      : inst.trendDirection
+
+  let cross = 0
+
+  if (hasPrevious && direction !== 0) {
+    cross = Number.isFinite(prevCross) &&
+            Math.sign(prevCross) === direction
+      ? prevCross + direction
+      : direction
   }
 
-  // Store previous raw smoothed HA values after cross calculation.
-  inst.prevSmOpen = smOpen;
-  inst.prevSmClose = smClose;
+  inst.trendDirection = direction
+  inst.prevSmOpen = smOpen
+  inst.prevSmClose = smClose
 
   // ---- HEIKEN ASHI STRUCTURE RETURNS ----
   const bodyTop = Math.max(smOpen, smClose);
@@ -205,10 +195,10 @@ export const heikenAshi = (
   const lowerWick = getRet(bodyBottom, smLow);
   const range = getRet(smHigh, smLow);
 
-  if (!isBadNumber(body)) main.pushToMain({ index, key: getKey('body'), value: body });
-  if (!isBadNumber(upperWick)) main.pushToMain({ index, key: getKey('upper_wick'), value: upperWick });
-  if (!isBadNumber(lowerWick)) main.pushToMain({ index, key: getKey('lower_wick'), value: lowerWick });
-  if (!isBadNumber(range)) main.pushToMain({ index, key: getKey('range'), value: range });
+  if (!isBadNumber(body)) main.pushToMain({ index, key: outputKeys.body, value: body });
+  if (!isBadNumber(upperWick)) main.pushToMain({ index, key: outputKeys.upper_wick, value: upperWick });
+  if (!isBadNumber(lowerWick)) main.pushToMain({ index, key: outputKeys.lower_wick, value: lowerWick });
+  if (!isBadNumber(range)) main.pushToMain({ index, key: outputKeys.range, value: range });
 
   // Do not add return logs to cross.
   main.pushToMain({ index, key: crossKey, value: cross });

package/src/moving-averages/movingAverages.js

@@ -4,6 +4,9 @@ import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
 import { mathLog } from '../utilities/math.js';
 
+const isBadNumber = v => v == null || !Number.isFinite(v);
+
+
 const indicatorClasses = {
   ema: FasterEMA, 
   sma: FasterSMA
@@ -27,27 +30,49 @@ export const movingAverages = (main, index, methodName, size, { target, lag, ret
     // Create the main moving average instance.
     instances[keyName] = new indicatorClasses[methodName](size)
 
-    initializeColumns(main, [{ key: keyName, priceBased: !retLogs && priceBased.has(target) }], { lag })
+    if(retLogs) {
+      initializeColumns(main, [
+        { key: `${keyName}_distance`, priceBased: false },
+        { key: `${keyName}_change`, priceBased: false }
+      ], { lag })
+    } else {
+      initializeColumns(main, [{ key: keyName, priceBased: priceBased.has(target) }], { lag })
+    }
+    
   }
 
   // Retrieve the current price value
-  const value = verticalOhlcv[target][index]
-  const instance = instances[keyName]
+  const currVal = verticalOhlcv[target][index];
+
+
+  if(isBadNumber(currVal)) return;
+
+  const instance = instances[keyName];
+
+  //The easiest way to compute prevMa change is to retrieve the previous result before updating the indicator.
+  const prevMa = instance.isStable ? instance.getResult() : NaN;
 
   // Update the moving average instance.
-  instance.update(value)
+  instance.update(currVal)
 
-  const currMa = instance.isStable ? instance.getResult() : NaN
+  const currMa = instance.isStable ? instance.getResult() : NaN;
+
+  if(isBadNumber(currMa)) return;
 
-  let output = currMa
   if (retLogs) {
-    const ratio = value / currMa
-    // Log-relative distance is defined only for finite, positive ratios and operands.
-    output = value > 0 && currMa > 0 && ratio > 0 && Number.isFinite(ratio)
-      ? mathLog(ratio, 1)
-      : NaN
+
+    const ratio = currVal / currMa;
+    const distance = mathLog(currVal, currMa);
+
+    main.pushToMain({ index, key: `${keyName}_distance`, value: distance })
+
+    if(isBadNumber(prevMa)) return;
+
+    const change = mathLog(currMa, prevMa);
+
+    main.pushToMain({ index, key: `${keyName}_change`, value: change })
+  } else {
+    main.pushToMain({ index, key: keyName, value: currMa })
   }
 
-  // Always push the selected value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: output })
 }

package/src/utilities/assignTypes.js

@@ -47,7 +47,7 @@ export const assignTypes = main => {
     }
     else if (colName === 'volume') {
       inputTypes[colName] = classifyNum(cellValue, true)
-      arrayTypes[colName] = 'Int32Array'
+      arrayTypes[colName] = 'Float64Array'
     }
     else if (initialPriceBased.has(colName)) {
       inputTypes[colName] = classifyNum(cellValue, true, precision)

package/src/utilities/validators.js

@@ -141,7 +141,7 @@ export const validateInputValues = (
     const value = verticalOhlcv[key]?.[index];
 
     const isValid = key === "volume"
-      ? Number.isInteger(value) && value >= 0
+      ? Number.isFinite(value) && value >= 0
       : Number.isFinite(value) && value > 0;
 
     if (!isValid) invalidParams.push(key);

package/webpack.config.js

@@ -1,6 +1,5 @@
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-//import TerserPlugin from 'terser-webpack-plugin';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -8,40 +7,12 @@ const entry = './index.js';
 const output = {
   filename: 'ohlcv-indicators.min.js',
   path: resolve(__dirname, './dist'),
-  library: 'OHLCV_INDICATORS'
+  library: {name: 'OHLCV_INDICATORS', type: 'var', export: 'default'}
 };
 
 export default {
   entry,
   output,
   mode: 'production',
-  target: 'web',
-/*   optimization: { //TerserPlugin start
-    minimize: true,
-    minimizer: [
-      new TerserPlugin({
-        terserOptions: {
-          output: {
-            beautify: true,  // Beautify the output
-            comments: true,  // Preserve comments
-          },
-        },
-      }),
-    ],
-  }, // TerserPlugin end */
-  module: {
-    rules: [
-      {
-        test: /\.js$/,
-        exclude: /node_modules/,
-        use: {
-          loader: 'babel-loader',
-          options: {
-            presets: ['@babel/preset-env'],
-            plugins: ['@babel/plugin-proposal-class-properties']
-          }
-        }
-      }
-    ]
-  }
+  target: 'web'
 };

package/dist/ohlcv-indicators.min.js.LICENSE.txt

@@ -1,22 +0,0 @@
-/*!
- * MIT License
- * Copyright (c) 2020 Benny Neugebauer
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */