ohlcv-indicators 2.1.4 → 2.1.6

package/src/moving-averages/movingAverages.js

@@ -0,0 +1,160 @@
+
+import {FasterEMA, FasterSMA, FasterBollingerBands} from 'trading-signals';
+import { classifyBoll } from '../utilities/classification.js'
+
+const indicatorClasses = {ema: FasterEMA, sma: FasterSMA} 
+
+export const movingAverages = (main, index, indicatorName, size, {target, diff}) => {
+
+  const {verticalOhlcv, instances, priceBased, lastIndexReplace} = main
+  let suffix =  (typeof target === 'string' && verticalOhlcv.hasOwnProperty(target) && target !== 'close') ? `_${target}` : ''
+  const keyName = `${indicatorName}_${size}${suffix}`
+  const diffKeyName = `${indicatorName}_${size}_diff${suffix}`
+
+  if(index === 0)
+  {
+      const {nullArray} = main
+
+      if(!verticalOhlcv.hasOwnProperty(target))
+      {
+          throw new Error(`Target property ${target} not found in verticalOhlcv for ${indicatorName}.`)
+      }
+
+      instances[keyName] = {
+        maInstance: new indicatorClasses[indicatorName](size)
+      }
+
+      verticalOhlcv[keyName] = [...nullArray]
+
+      if(diff !== null)
+      {
+        instances[keyName].diffInstance = new FasterBollingerBands(diff.size, diff.stdDev)
+
+        const lagDiffArr = []
+
+        for(const targetKey of diff.targets)
+        {
+          verticalOhlcv[`${diffKeyName}_${targetKey}`] = [...nullArray]
+
+          if(diff.lag > 0)
+          {
+            lagDiffArr.push(`${diffKeyName}_${targetKey}`)
+          }
+        }
+
+        if(diff.lag > 0)
+        {
+          console.log(lagDiffArr, diff.lag)
+          main.lag(lagDiffArr, diff.lag)
+        }
+      }
+
+      priceBased.push(keyName)
+  }
+
+  const value = verticalOhlcv[target][index]
+  const {maInstance, diffInstance} = instances[keyName]
+  maInstance.update(value, lastIndexReplace)
+
+  let currMa
+
+  try{
+    currMa = maInstance.getResult()
+  } catch(err)
+  {
+    //do nothing
+  }
+
+  if(currMa)
+  {
+    main.pushToMain({index, key: keyName, value: currMa})
+
+    if(diff === null)
+    {
+      return true
+    }
+
+    for(const targetKey of diff.targets)
+    {
+
+      const diffValue = (target === targetKey) ? value - currMa : verticalOhlcv[targetKey][index]
+
+      diffInstance.update(Math.abs(diffValue), lastIndexReplace)
+
+      let diffBoll
+
+      try {
+        diffBoll = diffInstance.getResult()
+      } catch(err)
+      {
+        diffBoll = null
+      }
+
+      main.pushToMain({index, key: `${diffKeyName}_${targetKey}`, value: classifyBoll(diffValue, diffBoll, diff.scale)})      
+
+    }
+
+
+
+  }
+
+}
+
+
+
+export const getMovingAveragesParams = (indicatorName, size, options, validMagnitudeValues) => {
+  if (!options || typeof options !== 'object') {
+    throw new Error(`"options" must be an object in ${indicatorName}. eg: {target, height, range}`);
+  }
+
+  let { target = 'close', diff = null } = options;
+
+  if(typeof target !== 'string')
+  {
+    throw new Error(`"target" must be a valid keyName ${indicatorName}.`);
+  }
+
+  if (typeof size !== 'number' || size <= 0) {
+    throw new Error(`"size" must be a positive number in ${indicatorName}.`);
+  }
+
+  //diff can be null, true, false or an object with optional {stdDev, scale, targets, and size}
+  const optionArgs = { target, diff: null };
+
+  if (diff !== null && (typeof diff === 'object' || (typeof diff === 'boolean' && diff === true))) {
+
+    diff = (diff === true) ? ({}) : diff
+
+    const {
+      stdDev = 2,
+      scale = 0.05,
+      targets = ['close'],
+      size: diffSize = size,
+      lag = 0
+    } = diff;
+
+    if (typeof stdDev !== 'number' || stdDev <= 0) {
+      throw new Error(`"diff.stdDev" must be a number greater than 0 in ${indicatorName}.`);
+    }
+
+    if (typeof scale !== 'number' || !validMagnitudeValues.includes(scale)) {
+      throw new Error(`"diff.scale" must be a number between 0.01 and 1 in ${indicatorName}.`);
+    }
+
+    if (typeof diffSize !== 'number' || !Number.isInteger(diffSize) || diffSize <= 0) {
+      throw new Error(`"diff.size" must be an integer greater than or equal to size in ${indicatorName}.`);
+    }
+
+    if (!Array.isArray(targets)) {
+      throw new Error(`"diff.targest" must be an array of keyNames with at least 1 item in ${indicatorName}.`);
+    }
+
+    if (typeof lag !== 'number' || !Number.isInteger(lag) || lag < 0) {
+      throw new Error(`"diff.lag" must be an integer greater than 0 in ${indicatorName}.`);
+    }
+
+    optionArgs.diff = { stdDev, scale, size: diffSize, targets, lag };
+  }
+
+  return optionArgs;
+}

package/src/moving-averages/relativeVolume.js

@@ -1,6 +1,7 @@
 import {FasterSMA} from 'trading-signals';
+import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-export const relativeVolume = (main, index, size = 10) => {
+export const relativeVolume = (main, index, size = 10, {scale}) => {
 
     const key = `relative_volume_${size}`
 
@@ -32,10 +33,22 @@ export const relativeVolume = (main, index, size = 10) => {
 
     const {prevRelativeVolumeSma} = main.instances[key]
 
+    let currRelativeVolume = null
+
+    if(smaValue !== null && prevRelativeVolumeSma !== null)
+    {
+        currRelativeVolume = value / prevRelativeVolumeSma
+
+        if(scale)
+        {
+            currRelativeVolume = calcMagnitude(currRelativeVolume, scale)
+        }
+    }
+
     main.pushToMain({
         index, 
         key,
-        value: (smaValue !== null && prevRelativeVolumeSma !== null) ? value / prevRelativeVolumeSma : null
+        value: currRelativeVolume
     })
 
     main.instances[key].prevRelativeVolumeSma = smaValue

package/src/oscillators/rsi.js

@@ -1,47 +1,65 @@
 import {FasterRSI} from 'trading-signals';
 import { FasterSMA } from 'trading-signals';
+import { calcMagnitude } from '../utilities/numberUtilities.js';
 
+const defaultTarget = 'close'
 
-export const rsi = (main, index, size) => {
+export const rsi = (main, index, size, {scale, target}) => {
     
-    const value = main.verticalOhlcv.close[index]
+    const {verticalOhlcv, instances, lastIndexReplace} = main
+    const suffix = (target === defaultTarget) ? '' : `_${target}`
+    const rsiKey = `rsi_${size}${suffix}`
+    const rsiSmaKey = `rsi_sma_${size}${suffix}`
 
     if(index === 0)
     {
-        main.crossPairsList.push({fast: `rsi_${size}`, slow: `rsi_sma_${size}`, isDefault: true})
+        const {crossPairsList, nullArray} = main
 
-        Object.assign(main.instances, {
-            [`rsi_${size}`]: new FasterRSI(size),
-            [`rsi_sma_${size}`]: new FasterSMA(size)
+        if(!verticalOhlcv.hasOwnProperty(target))
+        {
+            throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`)
+        }
+
+        crossPairsList.push({fast: rsiKey, slow: rsiSmaKey, isDefault: true})
+
+        Object.assign(instances, {
+            [rsiKey]: new FasterRSI(size),
+            [rsiSmaKey]: new FasterSMA(size)
         })
 
-        Object.assign(main.verticalOhlcv, {
-            [`rsi_${size}`]: [...main.nullArray],
-            [`rsi_sma_${size}`]: [...main.nullArray]
+        Object.assign(verticalOhlcv, {
+            [rsiKey]: [...nullArray],
+            [rsiSmaKey]: [...nullArray]
         })
     }
-    
+
+    const value = verticalOhlcv[target][index]
     let currentRsi
     let smoothedRsi
 
-    main.instances[`rsi_${size}`].update(value, main.lastIndexReplace)
+    instances[rsiKey].update(value, lastIndexReplace)
 
     try
     {
-        currentRsi = main.instances[`rsi_${size}`].getResult()
+        currentRsi = instances[rsiKey].getResult()
     } catch(err) {
         currentRsi = null
     }
     
     if(currentRsi)
     {
-        main.pushToMain({index, key: `rsi_${size}`, value: currentRsi})
-        main.instances[`rsi_sma_${size}`].update(currentRsi, main.lastIndexReplace)
+        if(scale)
+        {
+            currentRsi = calcMagnitude(currentRsi, scale)
+        }
+
+        main.pushToMain({index, key: rsiKey, value: currentRsi})
+        instances[rsiSmaKey].update(currentRsi, lastIndexReplace)
     }
 
     try
     {
-        smoothedRsi = main.instances[`rsi_sma_${size}`].getResult()
+        smoothedRsi = instances[rsiSmaKey].getResult()
     } catch(err)
     {
         smoothedRsi = null
@@ -49,7 +67,12 @@ export const rsi = (main, index, size) => {
 
     if(smoothedRsi)
     {
-        main.pushToMain({index, key: `rsi_sma_${size}`, value: smoothedRsi})
+        if(scale)
+        {
+            smoothedRsi = calcMagnitude(smoothedRsi, scale)
+        }
+
+        main.pushToMain({index, key: rsiSmaKey, value: smoothedRsi})
     }
 
     return true

package/src/oscillators/volumeOscillator.js

@@ -1,6 +1,7 @@
 import { FasterEMA } from 'trading-signals';
+import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-export const volumeOscillator = (main, index, fast, slow) => {
+export const volumeOscillator = (main, index, fast, slow, {scale}) => {
 
     const value = main.verticalOhlcv.volume[index]
     const key = 'volume_oscillator'
@@ -38,12 +39,19 @@ export const volumeOscillator = (main, index, fast, slow) => {
         slowValue = null;
     }
 
-    if (typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0) {
+    let volumeOscValue = null
 
-        main.pushToMain({index, key, value:  100 * (fastValue - slowValue) / slowValue})
-    } else {
-        main.pushToMain({index, key, value:  null})
+    if(typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0)
+    {
+        volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+
+        if(scale)
+        {
+            volumeOscValue = calcMagnitude(volumeOscValue, scale)
+        }
     }
 
+    main.pushToMain({index, key, value:  volumeOscValue})
+
     return true;
 };

package/src/studies/candleStudies.js

@@ -1,12 +1,9 @@
 import { FasterSMA, FasterBollingerBands } from 'trading-signals'
 import { classifyBoll } from '../utilities/classification.js'
 
-const diff = (a, b) => {
-    const value = a - b
-    return {value: Math.abs(value), positive: value >= 0}
-}
+const diff = (a, b) => a - b
 
-export const candleStudies = (main, index, size, stdDev, lag) => {
+export const candleStudies = (main, index, size, stdDev, {lag, scale}) => {
 
     const { verticalOhlcv, instances, lastIndexReplace } = main
 
@@ -14,16 +11,12 @@ export const candleStudies = (main, index, size, stdDev, lag) => {
     {
         const {nullArray} = main
 
-        Object.assign(verticalOhlcv, {
-            candle_gap: [...nullArray],
-            candle_body: [...nullArray],
-            candle_top: [...nullArray],
-            candle_bottom: [...nullArray],
-            candle_close: [...nullArray],
-            candle_high: [...nullArray],
-            candle_low: [...nullArray],
-            candle_open: [...nullArray],          
-        })
+        const candleParts = ['candle_body', 'candle_top', 'candle_bottom']
+        const candleGaps = ['candle_gap']
+        const candleChanges = ['candle_change_close', 'candle_change_high', 'candle_change_low', 'candle_change_open']
+        const keyNames = [...candleParts, ...candleGaps, ...candleChanges]
+
+        Object.assign(verticalOhlcv, Object.fromEntries(keyNames.map(k => [k, nullArray])))
 
         Object.assign(instances, {
             candleStudies: {
@@ -37,7 +30,6 @@ export const candleStudies = (main, index, size, stdDev, lag) => {
 
         if(lag > 0)
         {
-            const keyNames = ['candle_body', 'candle_gap', 'candle_close', 'candle_high', 'candle_low', 'candle_open', 'candle_top', 'candle_bottom']
             main.lag(keyNames, lag)
         }
         
@@ -57,11 +49,15 @@ export const candleStudies = (main, index, size, stdDev, lag) => {
     const currClose = verticalOhlcv.close[index]
 
 
-    //sizes
+    //parts
     const bodySize = diff(currClose, currOpen)
     const topSize = diff(currHigh, Math.max(currOpen, currClose))
     const bottomSize = diff(Math.min(currOpen, currClose), currLow)
-    const gapSize = diff(prevClose, currOpen)
+
+    //gaps
+    const gapOpenClose = diff(prevClose, currOpen)
+
+    //changes
     const closeChange = diff(currClose, prevClose)
     const highChange = diff(currHigh, prevHigh)
     const lowChange = diff(currLow, prevLow)
@@ -82,11 +78,11 @@ export const candleStudies = (main, index, size, stdDev, lag) => {
     } = instances.candleStudies
 
     // Update instances with current absolute values
-    bodyInstance.update(bodySize.value, lastIndexReplace)
-    closeInstance.update(closeChange.value, lastIndexReplace)
-    highInstance.update(highChange.value, lastIndexReplace)
-    lowInstance.update(lowChange.value, lastIndexReplace)
-    openInstance.update(openChange.value, lastIndexReplace)
+    bodyInstance.update(Math.abs(bodySize), lastIndexReplace)
+    closeInstance.update(Math.abs(closeChange), lastIndexReplace)
+    highInstance.update(Math.abs(highChange), lastIndexReplace)
+    lowInstance.update(Math.abs(lowChange), lastIndexReplace)
+    openInstance.update(Math.abs(openChange), lastIndexReplace)
 
     try {
         bodyBoll = bodyInstance.getResult()
@@ -99,15 +95,20 @@ export const candleStudies = (main, index, size, stdDev, lag) => {
     }
 
 
-    main.pushToMain({index, key: 'candle_close', value: classifyBoll(closeChange, closeBoll)})
-    main.pushToMain({index, key: 'candle_high', value: classifyBoll(highChange, highBoll)})
-    main.pushToMain({index, key: 'candle_low', value: classifyBoll(lowChange, lowBoll)})
-    main.pushToMain({index, key: 'candle_open', value: classifyBoll(openChange, openBoll)})
 
-    main.pushToMain({index, key: 'candle_body', value: classifyBoll(bodySize, bodyBoll)})
-    main.pushToMain({index, key: 'candle_gap', value: classifyBoll(gapSize, bodyBoll)})
-    main.pushToMain({index, key: 'candle_top', value: classifyBoll(topSize, bodyBoll)})
-    main.pushToMain({index, key: 'candle_bottom', value: classifyBoll(bottomSize, bodyBoll)})
+    //parts
+    main.pushToMain({index, key: 'candle_body', value: classifyBoll(bodySize, bodyBoll, scale)})
+    main.pushToMain({index, key: 'candle_top', value: classifyBoll(topSize, bodyBoll, scale)})
+    main.pushToMain({index, key: 'candle_bottom', value: classifyBoll(bottomSize, bodyBoll, scale)})
+
+    //gaps
+    main.pushToMain({index, key: 'candle_gap', value: classifyBoll(gapOpenClose, bodyBoll, scale)})
+
+    //changes
+    main.pushToMain({index, key: 'candle_change_close', value: classifyBoll(closeChange, closeBoll, scale)})
+    main.pushToMain({index, key: 'candle_change_high', value: classifyBoll(highChange, highBoll, scale)})
+    main.pushToMain({index, key: 'candle_change_low', value: classifyBoll(lowChange, lowBoll, scale)})
+    main.pushToMain({index, key: 'candle_change_open', value: classifyBoll(openChange, openBoll, scale)})
 
     return true
 }

package/src/utilities/classification.js

@@ -1,36 +1,48 @@
+import { calcMagnitude } from "./numberUtilities.js"
+
 /**
- * Classifies a given value relative to the Bollinger bands.
+ * Classifies a given value relative to provided Bollinger band thresholds.
  *
- * @param {Object} params - Parameters object.
- * @param {number} params.value - The value to classify.
- * @param {boolean} [params.positive=true] - Flag to determine if the result should be positive.
- * @param {Object} bollingerBands - Object containing the Bollinger band thresholds.
+ * The function evaluates the input value against the lower, middle, and upper thresholds
+ * of the Bollinger bands. If the value is below the lower threshold, it returns 0.
+ * If the value exceeds the upper threshold, it returns 1 (or -1 if the value is negative).
+ * For values within the bands, it calculates a normalized magnitude between 0 and 1 (or 0 and -1 for negatives)
+ * based on the position within the range, rounded to one decimal place.
+ * Additionally, if the value is nearly equal to the middle threshold (within a small tolerance),
+ * the function returns 0.5 or -0.5 depending on the sign of the value.
+ *
+ * @param {number} value - The value to classify.
+ * @param {Object} bollingerBands - An object containing Bollinger band thresholds.
  * @param {number} bollingerBands.upper - The upper band threshold.
  * @param {number} bollingerBands.middle - The middle band value.
  * @param {number} bollingerBands.lower - The lower band threshold.
- * @returns {number|null} The classified value, or null if inputs are invalid.
+ * @returns {number|null} The classified value, or null if inputs are invalid or if upper equals lower.
  */
-export const classifyBoll = ({ value, positive = true }, bollingerBands) => {
-    // Validate that value and bollingerBands are not null/undefined
-    if (value == null || bollingerBands == null) return null;
-  
-    const { upper, middle, lower } = bollingerBands;
-  
-  
-    // Handle values outside the Bollinger bands
-    if (value < lower) return 0;
-    if (value > upper) return positive ? 1 : -1;
-  
-    // Use a tolerance for floating point comparisons
-    const epsilon = Number.EPSILON * Math.max(Math.abs(value), Math.abs(middle));
-    if (Math.abs(value - middle) < epsilon) return positive ? 0.5 : -0.5;
-  
-    // Prevent division by zero if upper and lower are equal
-    if (upper === lower) return null;
-  
-    const rangeValue = (value - lower) / (upper - lower);
-    const magnitude = Math.round(rangeValue * 10) / 10;
-  
-    return positive ? magnitude : -magnitude;
-  };
-  
+
+
+export const classifyBoll = (value, bollingerBands, scale = 0.05) => {
+  // Validate that value and bollingerBands are not null/undefined
+  if (value == null || bollingerBands == null) return null
+
+  const positive = value >= 0
+
+  const { upper, middle, lower } = bollingerBands
+
+  // Handle values outside the Bollinger bands
+  if (value < lower) return 0
+  if (value > upper) return positive ? 1 : -1
+
+  // Use a tolerance for floating point comparisons
+  const epsilon = Number.EPSILON * Math.max(Math.abs(value), Math.abs(middle))
+  if (Math.abs(value - middle) < epsilon) return positive ? 0.5 : -0.5
+
+  // Prevent division by zero if upper and lower are equal
+  if (upper === lower) return null
+
+  const rangeValue = (value - lower) / (upper - lower)
+  let magnitude = calcMagnitude(rangeValue, scale)
+
+  magnitude = Math.min(Math.max(magnitude, 0), 1)
+
+  return positive ? magnitude : -magnitude
+}

package/src/utilities/{precision.js → numberUtilities.js}

@@ -1,3 +1,14 @@
+
+export const calcMagnitude = (number, magnitudeLevel = 0.1) => {
+
+    const factor = 1 / magnitudeLevel
+
+    return Math.round(number * factor) / factor
+}
+
+// Helper to clean non-numeric characters (except "-" at the start and decimal point)
+export const cleanNumStr = str => str.replace(/(?!^-)[^0-9.]/g, '');
+
 export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
     const output = {}
 

package/src/utilities/parsing-utilities.js

@@ -1,7 +1,6 @@
 import { validateInputParams } from "./validators.js";
 import { rsi } from "../oscillators/rsi.js";
-import { sma } from "../moving-averages/sma.js";
-import { ema } from "../moving-averages/ema.js";
+import { movingAverages } from "../moving-averages/movingAverages.js";
 import { macd } from "../moving-averages/macd.js";
 import { relativeVolume } from "../moving-averages/relativeVolume.js";
 import { donchianChannels } from "../moving-averages/donchianChannel.js";
@@ -13,16 +12,14 @@ import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
 import { priceVariations } from "../studies/priceVariations.js";
 
-// Helper to clean non-numeric characters (except "-" at the start and decimal point)
-const cleanNumStr = str => str.replace(/(?!^-)[^0-9.]/g, '');
+import { cleanNumStr } from "./numberUtilities.js";
 
 // Map indicator keys to their respective functions
 const indicatorFunctions = {
   dateTime,
   priceVariations,
   rsi,
-  sma,
-  ema,
+  movingAverages,
   macd,
   relativeVolume,
   donchianChannels,

package/src/moving-averages/ema.js

@@ -1,32 +0,0 @@
-
-import {FasterEMA} from 'trading-signals'
-
-export const ema = (main, index, size, target) => {
-
-  const value = main.verticalOhlcv.close[index]
-
-  let prefix =  (typeof target === 'string' && main.verticalOhlcv.hasOwnProperty(target) && target !== 'close') ? `${target}_` : ''
-  const keyName = `${prefix}ema_${size}`
-
-  if(index === 0)
-  {
-      main.instances[keyName] = new FasterEMA(size)
-      main.verticalOhlcv[keyName] = [...main.nullArray]
-  }
-
-  let currEma
-  main.instances[keyName].update(value, main.lastIndexReplace)
-
-  try{
-    currEma = main.instances[keyName].getResult()
-  } catch(err)
-  {
-    currEma = null
-  }
-
-  if(currEma)
-  {
-    main.pushToMain({index, key: keyName, value: currEma})
-  }
-
-}

package/src/moving-averages/sma.js

@@ -1,33 +0,0 @@
-
-import {FasterSMA} from 'trading-signals';
-
-export const sma = (main, index, size, target) => {
-
-  const value = main.verticalOhlcv.close[index]
-
-  let prefix =  (typeof target === 'string' && main.verticalOhlcv.hasOwnProperty(target) && target !== 'close') ? `${target}_` : ''
-  const keyName = `${prefix}sma_${size}`
-
-
-  if(index === 0)
-  {
-      main.instances[keyName] = new FasterSMA(size)
-      main.verticalOhlcv[keyName] = [...main.nullArray]
-  }
-
-  let currSma
-  main.instances[keyName].update(value, main.lastIndexReplace)
-
-  try{
-    currSma = main.instances[keyName].getResult()
-  } catch(err)
-  {
-    //do nothing
-  }
-
-  if(currSma)
-  {
-    main.pushToMain({index, key: keyName, value: currSma})
-  }
-
-}