ohlcv-indicators 2.1.5 → 2.1.6

package/index.js

@@ -3,7 +3,10 @@ import { correlation } from './src/studies/correlation.js'
 import { setIndicatorsFromInputParams } from './src/utilities/setIndicatorsFromInputParams.js'
 import { validateDate } from './src/utilities/validators.js'
 import { isAlreadyComputed } from './src/utilities/validators.js'
-import { divideByMultiplier } from './src/utilities/precision.js'
+import { divideByMultiplier } from './src/utilities/numberUtilities.js'
+import { getMovingAveragesParams } from './src/moving-averages/movingAverages.js'
+
+const validMagnitudeValues = [0.01, 0.02, 0.025, 0.05, 0.1, 0.20, 0.25, 0.5, 1]
 
 export default class OHLCV_INDICATORS {
     constructor({input, ticker = null, precision = true}) {
@@ -206,7 +209,7 @@ export default class OHLCV_INDICATORS {
         {
             const key = colKeys[x]
 
-            if(this.priceBased.find(v => key.startsWith(v)))
+            if(this.priceBased.find(v => key === v))
             {
                 this.priceBased.push(key)
             }
@@ -215,11 +218,18 @@ export default class OHLCV_INDICATORS {
         return this;
     }
     
-    relativeVolume(size) {
+    relativeVolume(size, options = {}) {
 
         isAlreadyComputed(this)
 
-        this.inputParams.push({key: 'relativeVolume', params: [size]})
+        const {scale = null} = options
+
+        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+
+            throw new Error(`"scale" value in relativeVolume must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+        }
+
+        this.inputParams.push({key: 'relativeVolume', params: [size, {scale}]})
  
         return this
     }
@@ -228,19 +238,9 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
 
-        if(!options || typeof options !== 'object')
-        {
-            throw new Error('"options" must be an object in ema. eg: {target, height, range}');
-        }
-
-        const {target = 'close'} = options
-
-        if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number in ema.');
-        }
+        const optionArgs = getMovingAveragesParams('ema', size, options, validMagnitudeValues)
 
-        this.inputParams.push({key: 'ema', params: [size, target]})
-        this.priceBased.push(`ema_${size}`)
+        this.inputParams.push({key: 'movingAverages', params: ['ema', size, optionArgs]})
 
         return this
     }
@@ -248,23 +248,14 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
 
-        if(!options || typeof options !== 'object')
-        {
-            throw new Error('"options" must be an object in sma. eg: {target, height, range}');
-        }
-
-        const {target = 'close'} = options
-
-        if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number in sma.');
-        }
-
+        const optionArgs = getMovingAveragesParams('sma', size, options, validMagnitudeValues)
 
-        this.inputParams.push({key: 'sma', params: [size, target]})
-        this.priceBased.push(`sma_${size}`)
+        this.inputParams.push({key: 'movingAverages', params: ['sma', size, optionArgs]})
 
-        return this 
+        return this
     }
+
+    
     macd(fast = 12, slow = 26, signal = 9, options = {}) {
 
         isAlreadyComputed(this)
@@ -300,7 +291,7 @@ export default class OHLCV_INDICATORS {
             throw new Error('"options" must be an object in bollingerBands. eg: {target, height, range}');
         }
 
-        const {target = 'close', height = false, range = [], zScore = []} = options
+        const {target = 'close', height = false, range = [], zScore = [], scale = null} = options
 
         // Validate size and times
         if (typeof size !== 'number' || size <= 0) {
@@ -317,15 +308,23 @@ export default class OHLCV_INDICATORS {
         }
         if (typeof height !== 'boolean') {
             throw new Error('"height" must be a boolean in bollingerBands.');
-        } 
+        }
+        else
+        {
+            if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+
+                throw new Error(`"scale" value in bollingerBands must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+            }           
+        }
+
+
     
-        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, range, zScore}]});
-        this.priceBased.push('bollinger_bands_middle', 'bollinger_bands_upper', 'bollinger_bands_lower');
+        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, scale, range, zScore}]});
     
         return this;
     }
     
-    rsi(size)
+    rsi(size, options = {})
     {
         isAlreadyComputed(this)
 
@@ -334,71 +333,97 @@ export default class OHLCV_INDICATORS {
             throw new Error('"size" must be a positive number in rsi.');
         }
 
-        this.inputParams.push({key: 'rsi', params: [size]})
+        const {scale = null, target = 'close'} = options
+
+        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+
+            throw new Error(`"scale" value in rsi must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+        }
+
+        this.inputParams.push({key: 'rsi', params: [size, {scale, target}]})
 
         return this
     }
-    donchianChannels(size = 20, offset = 0, options = {})
-    {
-        isAlreadyComputed(this)
-
+    donchianChannels(size = 20, offset = 0, options = {}) {
+        isAlreadyComputed(this);
+      
         if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number or 0 in donchianChannels.');
+          throw new Error('"size" must be a positive number greater than 0 in donchianChannels.');
         }
-    
+      
         if (typeof offset !== 'number' || offset < 0) {
-            throw new Error('"offset" must be a positive number or 0 in donchianChannels.');
+          throw new Error('"offset" must be a number greater than or equal to 0 in donchianChannels.');
         }
-
-        const {height = false, range = []} = options
-
+      
+        const { height = false, range = [], scale = null } = options;
+      
         if (!Array.isArray(range)) {
-            throw new Error('If set, "range" must be a array of column names in donchianChannels.');
+          throw new Error('If set, "range" must be an array of column names in donchianChannels.');
         }
- 
+      
         if (typeof height !== 'boolean') {
-            throw new Error('"height" must be a boolean in donchianChannels.');
-        } 
+          throw new Error('"height" must be a boolean in donchianChannels.');
+        }
+        else
+        {
 
-        this.inputParams.push({key: 'donchianChannels', params: [size, offset, {height, range}]})
-        this.priceBased.push('donchian_channel_upper', 'donchian_channel_lower', 'donchian_channel_basis')
+            if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
 
-        return this       
+                throw new Error(`"scale" value in donchianChannels must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+            }        
+        }
+      
+        this.inputParams.push({ key: 'donchianChannels', params: [size, offset, { height, range, scale }] });
+      
+        return this;
     }
-    candleStudies(size = 20, options = {})
-    {
-
-        isAlreadyComputed(this)
+      
 
+    candleStudies(size = 20, stdDev = 2, options = {}) {
+        isAlreadyComputed(this);
+      
         if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number or 0 in candleStudies.');
+          throw new Error('"size" must be a positive number greater than 0 in candleStudies.');
         }
+      
+        if (typeof stdDev !== 'number' || stdDev <= 0) {
+          throw new Error('"stdDev" must be a positive number greater than 0 in candleStudies.');
+        }
+      
+        const { lag = 0, scale = 0.05 } = options;
 
-        const {stdDev = 2, lag = 0} = options
 
-        if(typeof stdDev !== 'number' || (typeof stdDev === 'number' && stdDev <= 0))
-        {
-            throw new Error('"stdDev" must be a positive number greater than 0 in candleStudies.');
-        }
+        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
 
-        this.inputParams.push({key: 'candleStudies', params: [size, stdDev, lag]})
-        return this       
-    }
+            throw new Error(`"scale" value in candleStudies must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+        }
+      
+        this.inputParams.push({ key: 'candleStudies', params: [size, stdDev, {lag, scale}] });
+        return this;
+      }
+      
 
-    volumeOscillator(fastSize = 5, slowSize = 10)
+    volumeOscillator(fastSize = 5, slowSize = 10, options = {})
     {
 
         isAlreadyComputed(this)
 
-        if (typeof fastSize !== 'number' || fastSize <= 0) {
-            throw new Error('fastSize" must be a positive number in volumeOscillator.');
+        if (typeof fastSize !== 'number' || fastSize <= 1) {
+            throw new Error('fastSize" must be a positive number greater than 1 in volumeOscillator.');
         }
 
         if (typeof slowSize !== 'number' || slowSize <= fastSize) {
             throw new Error('"slowSize" must be a positive number greater than the "fastSize" in volumeOscillator.');
         }
 
-        this.inputParams.push({key: 'volumeOscillator', params: [fastSize, slowSize]})
+        const {scale = null} = options
+
+        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+
+            throw new Error(`"scale" value in volumeOscillator must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
+        }
+
+        this.inputParams.push({key: 'volumeOscillator', params: [fastSize, slowSize, {scale}]})
         return this           
     }
     dateTime()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "A JavaScript library featuring optimized trading indicators for OHLCV arrays [{open, high, low, close, value}]. This library is optimized for backtesting and trading bot development.",
   "main": "index.js",
   "type": "module",

package/src/moving-averages/bollingerBands.js

@@ -1,12 +1,12 @@
 import { FasterBollingerBands } from 'trading-signals'
+import { calcMagnitude } from '../utilities/numberUtilities.js';
 
 const defaultTarget = 'close'
 
-export const bollingerBands = (main, index, size, stdDev, options) => {
+export const bollingerBands = (main, index, size, stdDev, { height, range = [], zScore = [], target, scale }) => {
   // Destructure options ensure range and zScore default to empty arrays if not provided.
 
   const { verticalOhlcv, instances, lastIndexReplace } = main;
-  const { height, range = [], zScore = [], target } = options
   const suffix = target === defaultTarget ? '' : `_${target}`
   const indicatorKey = `${size}_${stdDev}${suffix}`
   let prefix // Will be computed during initialization
@@ -47,10 +47,12 @@ export const bollingerBands = (main, index, size, stdDev, options) => {
       ...(height && { [`${prefix}_height`]: [...nullArray] })
     }
 
+    main.priceBased.push(`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`)
+
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
       if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
-        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`)
+        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`)
       }
       ohlcvSetup[`${prefix}_range_${rangeKey}`] = [...nullArray]
     }
@@ -58,7 +60,7 @@ export const bollingerBands = (main, index, size, stdDev, options) => {
     // Set up additional arrays for each zScore property.
     for (const zScoreKey of zScore) {
       if (!(zScoreKey in verticalOhlcv) || !priceBased.includes(zScoreKey)) {
-        throw new Error(`Invalid zScore item value "${zScoreKey}" for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`)
+        throw new Error(`Invalid zScore item value "${zScoreKey}" for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`)
       }
       ohlcvSetup[`${prefix}_zscore_${zScoreKey}`] = [...nullArray]
     }
@@ -97,23 +99,40 @@ export const bollingerBands = (main, index, size, stdDev, options) => {
 
   // Process height if a height instance exists.
   if (height) {
-    const heightValue = ((upper - lower) / lower) * 100
+    let heightValue = ((upper - lower) / lower)
+
+    if(scale)
+    {
+      heightValue = calcMagnitude(heightValue, scale)
+    }
+
     main.pushToMain({index, key: `${subPrefix}_height`, value: heightValue})
   }
 
   // Process each range property.
   for (const rangeKey of range) {
-    const rangeValue = (verticalOhlcv[rangeKey][index] - lower) / (upper - lower)
+    let rangeValue = (verticalOhlcv[rangeKey][index] - lower) / (upper - lower)
+
+    if(scale)
+    {
+      rangeValue = calcMagnitude(rangeValue, scale)
+    }
+
     main.pushToMain({index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue})
   }
 
   // Process each zScore property.
   for (const zScoreKey of zScore) {
     const denominator = upper - lower
-    const zScoreValue = denominator !== 0
+    let zScoreValue = denominator !== 0
       ? (2 * stdDev * (verticalOhlcv[zScoreKey][index] - middle)) / denominator
       : 0
       
+    if(denominator !== 0 && scale)
+    {
+      zScoreValue = calcMagnitude(zScoreValue, scale)
+    }
+
     main.pushToMain({index, key: `${subPrefix}_zscore_${zScoreKey}`, value: zScoreValue})
   }
 

package/src/moving-averages/donchianChannel.js

@@ -1,41 +1,47 @@
+import { calcMagnitude } from "../utilities/numberUtilities.js"
+
+
+export const donchianChannels = (main, index, size, offset, { height, range, scale}) => {
 
-export const donchianChannels = (main, index, size, offset, options) => {
-  const { height, range } = options
   const indicatorKey = `${size}_${offset}`
+  const {verticalOhlcv, instances, len} = main
 
   // Initialization: create output arrays and indicator instance on the first call.
   if (index === 0) {
-    const numberOfIndicators = main.inputParams.filter(o => o.key === 'donchianChannels').length
+    const {inputParams, nullArray, priceBased} = main
+    const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length
     const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel'
 
-    Object.assign(main.verticalOhlcv, {
-      [`${prefix}_upper`]: [...main.nullArray],
-      [`${prefix}_basis`]: [...main.nullArray],
-      [`${prefix}_lower`]: [...main.nullArray],
-      ...(height && { [`${prefix}_height`]: [...main.nullArray] })
+    Object.assign(verticalOhlcv, {
+      [`${prefix}_upper`]: [...nullArray],
+      [`${prefix}_basis`]: [...nullArray],
+      [`${prefix}_lower`]: [...nullArray],
+      ...(height && { [`${prefix}_height`]: [...nullArray] })
     })
 
-    if (!main.instances.hasOwnProperty('donchian_channel')) {
-      main.instances.donchian_channel = { numberOfIndicators, settings: {} }
+    priceBased.push(`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`);
+
+    if (!instances.hasOwnProperty('donchian_channel')) {
+      instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in main.verticalOhlcv) || !main.priceBased.includes(rangeKey)) {
-        throw new Error(`Invalid range item value "${rangeKey}" property for donchianChannels. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`)
+      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+        throw new Error(`Invalid range item value "${rangeKey}" property for donchianChannels. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`)
       }
-      main.verticalOhlcv[`${prefix}_range_${rangeKey}`] = [...main.nullArray]
+      verticalOhlcv[`${prefix}_range_${rangeKey}`] = [...nullArray]
     }
 
-    main.instances.donchian_channel.settings[indicatorKey] = {
+    instances.donchian_channel.settings[indicatorKey] = {
       maxDeque: [], // will hold indices for highs in descending order
       minDeque: []  // will hold indices for lows in ascending order
     }
   }
 
-  const numberOfIndicators = main.instances.donchian_channel.numberOfIndicators
+  const numberOfIndicators = instances.donchian_channel.numberOfIndicators
   const subPrefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel'
-  const state = main.instances.donchian_channel.settings[indicatorKey]
+  const state = instances.donchian_channel.settings[indicatorKey]
   const { maxDeque, minDeque } = state
 
   // Compute the “current bar index” for the window.
@@ -45,10 +51,10 @@ export const donchianChannels = (main, index, size, offset, options) => {
   const startIdx = endIdx - size        // window: [startIdx, endIdx)
 
   // If the window is not fully available, exit early.
-  if (startIdx < 0 || endIdx > main.len) return true
+  if (startIdx < 0 || endIdx > len) return true
 
-  const highs = main.verticalOhlcv.high
-  const lows = main.verticalOhlcv.low
+  const highs = verticalOhlcv.high
+  const lows = verticalOhlcv.low
 
   // **Update the maximum deque:**
   // Remove indices that are out of the current window.
@@ -86,13 +92,25 @@ export const donchianChannels = (main, index, size, offset, options) => {
   main.pushToMain({index, key: `${subPrefix}_lower`, value: lower})
 
   if (height) {
-    const heightValue = ((upper - lower) / lower) * 100
+    let heightValue = ((upper - lower) / lower)
+
+    if(scale)
+    {
+      heightValue = calcMagnitude(heightValue, scale)
+    }
+
     main.pushToMain({index, key: `${subPrefix}_height`, value: heightValue})
   }
 
   // Process each range property.
   for (const rangeKey of range) {
-    const rangeValue = (main.verticalOhlcv[rangeKey][index] - lower) / (upper - lower)
+    let rangeValue = (verticalOhlcv[rangeKey][index] - lower) / (upper - lower)
+
+    if(scale)
+    {
+      rangeValue = calcMagnitude(rangeValue, scale)
+    }
+
     main.pushToMain({index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue})
   }
 

package/src/moving-averages/macd.js

@@ -1,73 +1,77 @@
-import {FasterEMA, FasterMACD} from 'trading-signals';
+import { FasterEMA, FasterMACD } from 'trading-signals';
 
-const defaultTarget = 'close'
+const defaultTarget = 'close';
 
 export const macd = (main, index, fast, slow, signal, options) => {
+  const { target } = options;
+  const { verticalOhlcv, instances } = main;
 
-    const {target} = options
-    const suffix = target === defaultTarget ? '' : `_${target}`;
-    const indicatorKey = `${fast}_${slow}_${signal}${suffix}`;
-
-    if (index === 0) {
-
-        if(!main.verticalOhlcv.hasOwnProperty(target))
-        {
-            throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
-        }
-
-        const numberOfIndicators = main.inputParams.filter(o => o.key === 'macd').length;
-        const prefix =
-          numberOfIndicators > 1
-            ? `macd_${indicatorKey}`
-            : `macd${suffix}`;
-
-        main.crossPairsList.push({fast: `${prefix}_diff`, slow: `${prefix}_dea`, isDefault: true});
-
-        if(!main.instances.hasOwnProperty('macd'))
-        {
-            main.instances.macd = {
-                numberOfIndicators,
-                settings: {}
-              }
-        }
-
-        main.instances.macd.settings[indicatorKey] = new FasterMACD(
-            new FasterEMA(fast),
-            new FasterEMA(slow),
-            new FasterEMA(signal)
-        );
-
-        Object.assign(main.verticalOhlcv, {
-            [`${prefix}_diff`]: [...main.nullArray],
-            [`${prefix}_dea`]: [...main.nullArray],
-            [`${prefix}_histogram`]: [...main.nullArray],
-        })
-    }
+  // Instance key (for internal storage) includes target if not default.
+  const instanceKey = `${fast}_${slow}_${signal}${target === defaultTarget ? '' : `_${target}`}`;
+
+  // On the first index, do the initialization.
+  if (index === 0) {
+    const { inputParams, crossPairsList, nullArray } = main;
 
-    
-    const subPrefix = main.instances.macd.numberOfIndicators > 1
-        ? `macd_${indicatorKey}`
-        : `macd${suffix}`;
-
-    const macdInstance = main.instances.macd.settings[indicatorKey];
-    const value = main.verticalOhlcv[target][index]
-    macdInstance.update(value, main.lastIndexReplace);
-
-    let macdResult;
-    
-    try {
-        macdResult = macdInstance.getResult();
-    } catch (err) {
-        //do nothing
+    if (!verticalOhlcv.hasOwnProperty(target)) {
+      throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`);
     }
 
+    const numberOfIndicators = inputParams.filter(o => o.key === 'macd').length;
+    // For display keys: if there's more than one indicator, include the parameters in the prefix.
+    const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd';
+
+    // Build the keys: if target is not the default, append it at the end.
+    const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`;
+    const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`;
+    const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`;
 
-    if (macdResult) {
+    crossPairsList.push({ fast: diffKey, slow: deaKey, isDefault: true });
 
-        main.pushToMain({index, key: `${subPrefix}_diff`, value: macdResult.macd})
-        main.pushToMain({index, key: `${subPrefix}_dea`, value: macdResult.signal})
-        main.pushToMain({index, key: `${subPrefix}_histogram`, value: macdResult.histogram})
+    if (!instances.hasOwnProperty('macd')) {
+      instances.macd = {
+        numberOfIndicators,
+        settings: {}
+      };
     }
 
-    return true;
+    instances.macd.settings[instanceKey] = new FasterMACD(
+      new FasterEMA(fast),
+      new FasterEMA(slow),
+      new FasterEMA(signal)
+    );
+
+    Object.assign(verticalOhlcv, {
+      [diffKey]: [...nullArray],
+      [deaKey]: [...nullArray],
+      [histogramKey]: [...nullArray],
+    });
+  }
+
+  const {numberOfIndicators, settings} = instances.macd
+
+  // Determine display prefix for updating values.
+  const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd';
+  const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`;
+  const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`;
+  const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`;
+
+  const macdInstance = settings[instanceKey];
+  const value = verticalOhlcv[target][index];
+  macdInstance.update(value, main.lastIndexReplace);
+
+  let macdResult;
+  try {
+    macdResult = macdInstance.getResult();
+  } catch (err) {
+    // Do nothing if no result is available.
+  }
+
+  if (macdResult) {
+    main.pushToMain({ index, key: diffKey, value: macdResult.macd });
+    main.pushToMain({ index, key: deaKey, value: macdResult.signal });
+    main.pushToMain({ index, key: histogramKey, value: macdResult.histogram });
+  }
+
+  return true;
 };

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})
-  }
-
-}