ohlcv-indicators 3.3.1 → 3.3.4

package/src/oscillators/rsi.js

@@ -1,11 +1,10 @@
 import { FasterRSI } from 'trading-signals';
 import { FasterSMA } from 'trading-signals';
-import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-const defaultTarget = 'close';
+const defaultTarget = 'close'
+export const rsi = (main, index, size, { target, lag }) => {
+  const { verticalOhlcv, instances } = main;
 
-export const rsi = (main, index, size, { scale, target, lag, autoMinMax }) => {
-  const { verticalOhlcv, instances, lastIndexReplace } = main;
   const suffix = target === defaultTarget ? '' : `_${target}`;
   const rsiKey = `rsi_${size}${suffix}`;
   const rsiSmaKey = `rsi_sma_${size}${suffix}`;
@@ -13,7 +12,7 @@ export const rsi = (main, index, size, { scale, target, lag, autoMinMax }) => {
   // Initialization on the first index.
   if (index === 0) {
 
-    const { crossPairsList, nullArray } = main;
+    const { crossPairsList, len, arrayTypes } = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
@@ -27,55 +26,52 @@ export const rsi = (main, index, size, { scale, target, lag, autoMinMax }) => {
     });
 
     Object.assign(verticalOhlcv, {
-      [rsiKey]: [...nullArray],
-      [rsiSmaKey]: [...nullArray],
+      [rsiKey]: new Float64Array(len).fill(NaN),
+      [rsiSmaKey]: new Float64Array(len).fill(NaN),
     });
 
+
+
+    const keyNames = [rsiKey, rsiSmaKey]
+
     if(lag > 0)
     {
-      main.lag([rsiKey, rsiSmaKey], lag)
+      main.lag(keyNames, lag)
     }
 
-    if(autoMinMax)
+    for(const key of keyNames)
     {
-      main.autoMinMaxKeys.push(rsiKey, rsiSmaKey)
+      arrayTypes[key] = 'Float64Array'
     }
 
   }
 
   const value = verticalOhlcv[target][index];
-  let currentRsi = null;
-  let smoothedRsi = null;
+  let currentRsi = NaN;
+  let smoothedRsi = NaN;
 
   // Update the RSI indicator.
-  instances[rsiKey].update(value, lastIndexReplace);
+  instances[rsiKey].update(value);
 
   try {
     currentRsi = instances[rsiKey].getResult();
   } catch (err) {
-    currentRsi = null;
+    currentRsi = NaN;
   }
 
-  if (currentRsi !== null && typeof currentRsi === 'number' && scale) {
-    currentRsi = calcMagnitude(currentRsi, scale);
-  }
 
-  // Always push the RSI value, using null as a fallback.
+  // Always push the RSI value, using NaN as a fallback.
   main.pushToMain({ index, key: rsiKey, value: currentRsi });
 
   // Update the SMA indicator only if a valid RSI value is available.
-  if (currentRsi !== null && typeof currentRsi === 'number') {
-    instances[rsiSmaKey].update(currentRsi, lastIndexReplace);
+  if (!Number.isNaN(currentRsi)) {
+    instances[rsiSmaKey].update(currentRsi);
   }
 
   try {
     smoothedRsi = instances[rsiSmaKey].getResult();
   } catch (err) {
-    smoothedRsi = null;
-  }
-
-  if (smoothedRsi !== null && typeof smoothedRsi === 'number' && scale) {
-    smoothedRsi = calcMagnitude(smoothedRsi, scale);
+    smoothedRsi = NaN;
   }
 
   // Always push the smoothed RSI value.

package/src/oscillators/volumeOscillator.js

@@ -1,15 +1,14 @@
 import { FasterEMA } from 'trading-signals';
-import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-export const volumeOscillator = (main, index, fast, slow, {scale}) => {
+export const volumeOscillator = (main, index, fast, slow, {lag}) => {
 
-    const {verticalOhlcv, instances, lastIndexReplace} = main
+    const {verticalOhlcv, instances} = main
     const value = verticalOhlcv.volume[index]
     const key = 'volume_oscillator'
 
     if (index === 0) {
 
-        const {crossPairsList, nullArray} = main
+        const {crossPairsList, len, arrayTypes} = main
         Object.assign(instances, {
             volume_oscillator: {
                 fastEMA: new FasterEMA(fast),
@@ -17,40 +16,42 @@ export const volumeOscillator = (main, index, fast, slow, {scale}) => {
             }
         })
 
-        verticalOhlcv[key] = [...nullArray];
-        crossPairsList.push({ fast: key, slow: 0, isDefault: true });
+        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
+        crossPairsList.push({ fast: key, slow: 0, isDefault: true })
+
+        if(lag > 0)
+        {
+            main.lag([key], lag)
+        }
+
+        arrayTypes[key] = 'Float64Array'
     }
 
     const { fastEMA, slowEMA } = instances[key];
 
-    fastEMA.update(value, lastIndexReplace);
-    slowEMA.update(value, lastIndexReplace);
+    fastEMA.update(value);
+    slowEMA.update(value);
 
-    let fastValue = null;
-    let slowValue = null;
+    let fastValue = NaN;
+    let slowValue = NaN;
 
     try {
         fastValue = fastEMA.getResult();
     } catch (err) {
-        fastValue = null;
+        
     }
 
     try {
         slowValue = slowEMA.getResult();
     } catch (err) {
-        slowValue = null;
+
     }
 
-    let volumeOscValue = null
+    let volumeOscValue = NaN
 
-    if(typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0)
+    if(!Number.isNaN(fastValue) && !Number.isNaN(slowValue))
     {
         volumeOscValue = 100 * (fastValue - slowValue) / slowValue
-
-        if(scale)
-        {
-            volumeOscValue = calcMagnitude(volumeOscValue, scale)
-        }
     }
 
     main.pushToMain({index, key, value:  volumeOscValue})

package/src/studies/dateTime.js

@@ -1,36 +1,39 @@
-export const dateTime = (main, index) => {
+export const dateTime = (main, index, {lag}) => {
 
     const {instances, verticalOhlcv} = main
  
     if(index === 0)
     {
-        const {nullArray, isValidDate} = main
-        if(!isValidDate) throw Error('dateTime method found and invalid "date" in input ohlcv')
-
-        const index0DateStr = verticalOhlcv.date[0].slice(0, 10)
+        const {len, dateType, arrayTypes} = main
+        if(!dateType) throw Error('dateTime method found and invalid "date" in input ohlcv')
 
         Object.assign(instances, {
             dateTime: {
-                prevDateStr: index0DateStr,
+                prevDateStr: verticalOhlcv.date[0],
                 sessionDailyIndexCount: 0,
                 sessionIntradayIndexCount: 0,
-                cachedDayInfo: index0DateStr
+                cachedDayInfo: verticalOhlcv.date[0]
             }
         })
 
-        Object.assign(verticalOhlcv, {
-            day_of_the_week: [...nullArray],
-            day_of_the_month: [...nullArray],
-            week_of_the_month: [...nullArray],
-            hour: [...nullArray],
-            month: [...nullArray],
-            year: [...nullArray],
-            session_daily_index: [...nullArray],
-            session_intraday_index: [...nullArray],
-        })
+        const colKeys = ['day_of_the_week', 'day_of_the_month', 'week_of_the_month', 'hour', 'month', 'year', 'session_daily_index', 'session_intraday_index']
+
+        for(const key of colKeys)
+        {
+            arrayTypes[key] = 'Int32Array'
+        }
+
+        Object.assign(verticalOhlcv, {...Object.fromEntries(colKeys.map(k => [k, new Int32Array(len).fill(NaN)]))})
+
+        if(lag > 0)
+        {
+            main.lag(colKeys, lag)
+        }
     }
 
+
     const currDate = verticalOhlcv.date[index]
+
     const {
         day_of_the_week,
         day_of_the_month,
@@ -41,7 +44,7 @@ export const dateTime = (main, index) => {
     } = getDateInfo(currDate)
 
 
-    const currDateStr = currDate.slice(0, 10)
+    const currDateStr = currDate
 
     if(currDateStr !== instances.dateTime.prevDateStr)
     {
@@ -68,8 +71,7 @@ export const dateTime = (main, index) => {
 
 
 
-const getDateInfo = dateString => {
-    const date = new Date(dateString)
+const getDateInfo = date => {
     const month = date.getMonth()
     const year = date.getFullYear()
     const hour = date.getHours()

package/src/studies/findCrosses.js

@@ -15,12 +15,11 @@ class CrossInstance {
         Object.assign(this, {
             interval: 0,
             prevState: 0.5,
-            prevFast: null,
-            prevSlow: null,
-            prevHigh: null,
-            prevLow: null,
+            prevFast: NaN,
+            prevSlow: NaN,
+            prevHigh: NaN,
+            prevLow: NaN,
             areHighAndLowUndefined: false,
-            index: 0,
             crossIndexes: {
                 up: [],
                 down: []
@@ -28,7 +27,7 @@ class CrossInstance {
         })        
 
     }
-    update({fast, high, slow, low})
+    update(index, {fast, high, slow, low})
     {
         let currState = this.prevState
 
@@ -40,7 +39,7 @@ class CrossInstance {
             }
         }
 
-        if(fast === null || slow === null){
+        if(Number.isNaN(fast) || Number.isNaN(slow)){
             currState = 0.5
         }
         else if(eq(fast, slow)) {
@@ -54,7 +53,7 @@ class CrossInstance {
             }
             else
             {
-                if ([low, slow, this.prevLow, this.prevSlow].every(v => v !== null) && lt(low, slow) && gt(this.prevLow, this.prevSlow))
+                if ([low, slow, this.prevLow, this.prevSlow].every(v => !Number.isNaN(v)) && lt(low, slow) && gt(this.prevLow, this.prevSlow))
                 {
                     currState = 0
                 }
@@ -72,7 +71,7 @@ class CrossInstance {
             }
             else
             {
-                if([high, slow, this.prevHigh, this.prevSlow].every(v => v !== null) && gt(high, slow) && lt(this.prevHigh, this.prevSlow))
+                if([high, slow, this.prevHigh, this.prevSlow].every(v => !Number.isNaN(v)) && gt(high, slow) && lt(this.prevHigh, this.prevSlow))
                 {
                     currState = 1
                 }
@@ -111,12 +110,11 @@ class CrossInstance {
         }
 
 
-        if(this.interval === 1) this.crossIndexes.up.push(this.index)
-        if(this.interval === -1) this.crossIndexes.down.push(this.index)
+        if(this.interval === 1) this.crossIndexes.up.push(index)
+        if(this.interval === -1) this.crossIndexes.down.push(index)
 
         //save prev state
         Object.assign(this, {
-            index: this.index + 1,
             prevState: currState,
             prevFast: fast,
             prevSlow: slow,
@@ -134,7 +132,7 @@ class CrossInstance {
 
 export const crossPairs = (main, index) => {
 
-    const {nullArray, verticalOhlcv, instances, len} = main
+    const {verticalOhlcv, instances, len, arrayTypes} = main
 
     if(index === 0)
     {
@@ -158,7 +156,7 @@ export const crossPairs = (main, index) => {
         {
             if(typeof slow === 'number')
             {
-                verticalOhlcv[slow] = new Array(len).fill(slow)
+                verticalOhlcv[slow] = new Int32Array(len).fill(slow)
             }
             
             if(fast !== 'price' && !verticalOhlcv.hasOwnProperty(fast)) throw Error(`fast "${fast} not found in crossPairs"`)
@@ -167,7 +165,9 @@ export const crossPairs = (main, index) => {
 
             instances[crossName] = new CrossInstance()
 
-            verticalOhlcv[crossName] = [...nullArray]
+            verticalOhlcv[crossName] = new Int32Array(len).fill(NaN)
+
+            arrayTypes[crossName] = 'Int32Array'
         }
 
         let fastValue
@@ -183,14 +183,14 @@ export const crossPairs = (main, index) => {
             lowValue = verticalOhlcv.low[index]
             slowValue = verticalOhlcv[slow][index]
 
-            instances[crossName].update({fast: closeValue, slow: slowValue, high: highValue, low: lowValue})
+            instances[crossName].update(index, {fast: closeValue, slow: slowValue, high: highValue, low: lowValue})
 
         } else
         {
             fastValue = verticalOhlcv[fast][index]
             slowValue = verticalOhlcv[slow][index]
 
-            instances[crossName].update({fast: fastValue, slow: slowValue})
+            instances[crossName].update(index, {fast: fastValue, slow: slowValue})
         }
 
         main.pushToMain({index, key: crossName, value: instances[crossName].getResult()})

package/src/studies/lag.js

@@ -1,24 +1,26 @@
+import { buildArray } from "../utilities/assignTypes.js";
+
 export const lag = (main, index) => {
 
-    const {instances, verticalOhlcv, nullArray} = main
+    const {instances, verticalOhlcv, len, arrayTypes, priceBased} = main
 
     if(index === 0)
     {
-        const {inputParams, priceBased} = main
+        const {inputParams} = main
         const findParams = inputParams.filter(o => o.key === 'lag')
 
         if(typeof findParams !== 'object') return
 
         const params = findParams.map(o => o.params)
 
-        for (const [colKeys, lags] of params)
+        for (const [colKeys, lookback] of params)
         {
             for (const colKey of colKeys)
             {
                 if(priceBased.includes(colKey))
                 {
-                    for (let lag = 1; lag <= lags; lag++) {
-                        priceBased.push(`${colKey}_lag_${lag}`)
+                    for (let step = 1; step <= lookback; step++) {
+                        priceBased.push(`${colKey}_lag_${step}`)
                     }
                 }
             }
@@ -31,23 +33,30 @@ export const lag = (main, index) => {
     
     const {lagParams} = instances.lag
 
-    for (const [colKeys, lags] of lagParams) {
+    for (const [colKeys, lookback] of lagParams) {
     
         for (const colKey of colKeys) {
             const currentColumn = verticalOhlcv[colKey];
     
             // Initialize lagged arrays only on the first index
             if (index === 0) {
-                for (let lag = 1; lag <= lags; lag++) {
-                    const key = `${colKey}_lag_${lag}`;
-                    verticalOhlcv[key] = [...nullArray];
+                for (let step = 1; step <= lookback; step++) {
+                    const key = `${colKey}_lag_${step}`;
+
+                    if(!arrayTypes.hasOwnProperty(colKey))
+                    {
+                        throw new Error(`Lag processing invoked by "${colKey}" expected arrayTypes to have a "${colKey}" property, but it wasn’t found.`)                          
+                    }
+
+                    verticalOhlcv[key] = buildArray(arrayTypes[colKey], len)
+                    arrayTypes[key] = arrayTypes[colKey]
                 }
             }
 
             // Populate lagged values
-            for (let lag = 1; lag <= lags; lag++) {
-                const key = `${colKey}_lag_${lag}`;
-                const laggedIndex = index - lag;
+            for (let step = 1; step <= lookback; step++) {
+                const key = `${colKey}_lag_${step}`;
+                const laggedIndex = index - step;
 
                 const value = (laggedIndex <= 0 || typeof currentColumn[laggedIndex] === 'undefined') 
                     ? null 

package/src/studies/scaler.js

@@ -0,0 +1,112 @@
+/* General Scaler: supports "minmax" and "zscore" types */
+
+const normalizeMinMax = (value, min, max, [validMin, validMax]) => {
+    const clamped = Math.min(Math.max(value, min), max);
+    return ((clamped - min) / (max - min)) * (validMax - validMin) + validMin;
+  };
+  
+  const normalizeZScore = (value, mean, std) => {
+    return std === 0 ? 0 : (value - mean) / std;
+  };
+  
+export const Scaler = (
+    main,
+    index,
+    size,
+    colKeys,
+    type,
+    group,
+    range,         // used for minmax: [validMin, validMax]
+    lag,
+  ) => {
+    const { verticalOhlcv, instances, arrayTypes } = main;
+    const prefix = `${type}_${size}`;
+    let groupKey = '';
+  
+    if (index === 0) {
+      const { len, priceBased, groups } = main;
+      groupKey = `${prefix}_group_${colKeys.join('_')}`;
+  
+      instances.scaler = {
+        groupKeyLen: colKeys.length,
+        groupKey,
+        windows: {}           // stores arrays of past values for each key or group
+      };
+  
+      for (const target of colKeys) {
+        if (!verticalOhlcv.hasOwnProperty(target)) {
+          throw new Error(`Target property "${target}" not found in verticalOhlcv`);
+        }
+        if (!priceBased.includes(target)) {
+          throw new Error(`Column "${target}" is not priceBased and cannot be scaled.`);
+        }
+  
+        const key = `${prefix}_${target}`;
+        verticalOhlcv[key] = new Float64Array(len).fill(NaN);
+        arrayTypes[key] = 'Float64Array'
+  
+        const winKey = group ? groupKey : target;
+        instances.scaler.windows[winKey] = [];
+  
+        if (group) {
+          if (!main.ScaledGroups[groupKey]) main.ScaledGroups[groupKey] = [];
+          main.ScaledGroups[groupKey].push(key);
+        }
+  
+        if (lag > 0) {
+          if (group) {
+            const lags = Array.from({ length: lag }).map((_, i) => `${key}_lag_${i + 1}`);
+            main.ScaledGroups[groupKey].push(...lags);
+          }
+          main.lag([key], lag);
+        }
+      }
+    }
+  
+    const { windows } = instances.scaler;
+    groupKey = instances.scaler.groupKey;
+  
+    // update windows with current values
+    for (const target of colKeys) {
+      const val = verticalOhlcv[target][index];
+      const winKey = group ? groupKey : target;
+      const win = windows[winKey];
+  
+      win.push(val);
+      
+      if (win.length > (group ? size * instances.scaler.groupKeyLen : size)) {
+        win.shift();
+      }
+
+    }
+  
+    const ready = index + 1 >= size;
+  
+    // scale values once enough data
+    for (const target of colKeys) {
+      const val = verticalOhlcv[target][index];
+      const key = `${prefix}_${target}`;
+      let scaled = null;
+  
+      if (ready) {
+        const winKey = group ? groupKey : target;
+        const win = windows[winKey];
+  
+        if (type === 'minmax') {
+          const mn = Math.min(...win);
+          const mx = Math.max(...win);
+          scaled = normalizeMinMax(val, mn, mx, range);
+        } else if (type === 'zscore') {
+          const mean = win.reduce((sum, x) => sum + x, 0) / win.length;
+          const variance = win.reduce((sum, x) => sum + Math.pow(x - mean, 2), 0) / win.length;
+          const std = Math.sqrt(variance);
+          scaled = normalizeZScore(val, mean, std);
+        } else {
+          throw new Error(`Unknown scaler type "${type}"`);
+        }
+      }
+  
+      main.pushToMain({ index, key, value: scaled });
+    }
+  };
+  

package/src/utilities/assignTypes.js

@@ -0,0 +1,39 @@
+import { classifyNum } from "./numberUtilities.js";
+import { selectDateFormatter } from "./dateUtilities.js";
+
+const numberKeys = ['open', 'high', 'low', 'close']
+
+export const buildArray = (arrayType, len) => {
+  if(arrayType === 'Array') return new Array(len).fill(null)
+  if(arrayType === 'Float64Array') return new Float64Array(len).fill(NaN)
+  if(arrayType === 'Int32Array') return new Int32Array(len).fill(NaN)
+}
+
+export const assignTypes = firstRow => {
+  const inputTypes  = {}
+  const arrayTypes  = {}
+
+  for (const [colName, cellValue] of Object.entries(firstRow)) {
+
+    if (colName === 'date') {
+      inputTypes[colName] = selectDateFormatter(cellValue, true)
+      arrayTypes[colName] = 'Array'
+    }
+    else if(colName === 'volume')
+    {
+      inputTypes[colName] = classifyNum(cellValue, true)
+      arrayTypes[colName] = 'Int32Array'
+    }
+    else if(numberKeys.includes(colName))
+    {
+      inputTypes[colName] = classifyNum(cellValue, true)
+      arrayTypes[colName] = 'Float64Array'
+    } else {
+      const thisType = classifyNum(cellValue, false)
+      inputTypes[colName] = thisType
+      arrayTypes[colName] = (thisType === 'number') ? 'Float64Array' : 'Array'
+    }
+  }
+
+  return { inputTypes, arrayTypes }
+}

package/src/utilities/dateUtilities.js

@@ -0,0 +1,79 @@
+export const dateFormaters = {
+    dateObject: d => d,
+    dateMilliseconds: d => new Date(d),
+    dateSeconds: d => new Date(d * 1000),
+    dateIncompleteDayString: d => new Date(`${d}  00:00:00`),
+    dateCompleteDateString: d => new Date(d)
+}
+
+export const selectDateFormatter = value => {
+
+    // Regex for a UTC Time Format where the string ends with "Z".
+    const utcRegex = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/i;
+    
+    // Regex for a Timezone Offset Format,
+    // which includes a plus or minus sign followed by HH:MM at the end.
+    const offsetRegex = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?([+-]\d{2}:\d{2})$/;
+    
+    // Regex for a Local Time Format that contains no timezone indicator.
+    const localRegex = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
+  
+    // Regex for a YYYY-MM-DD Format.
+    const YYMMDDRegexDash = /^\d{4}-\d{2}-\d{2}$/;
+    const YYMMDDRegexSlash = /^\d{4}\/\d{2}\/\d{2}$/;
+  
+    const validFormatNames = [
+      'Date -> object',
+      'Milliseconds Timestamp -> integer',
+      'Seconds Timestamp -> integer',
+      'UTC Time Format (ISO 8601) -> string',
+      'Including a Timezone Offset (ISO 8601) -> string',
+      'Local Time Format (ISO 8601) -> string',
+      'YYYY/MM/DD or YYYY-MM-DD -> string',
+    ]
+  
+    const errorMessage = () => {
+      throw new Error(`Invalid "${typeof value}" date value passed in selectDateFormatter. Supported formats: \n-${validFormatNames.join("\n- ")}`)
+    }
+  
+    if(typeof value === 'object')
+    {
+      if(value instanceof Date && !isNaN(value.valueOf()))
+      {
+        return 'dateObject'
+      }
+      else
+      {
+        errorMessage()
+      }
+    }
+    else if (typeof value === 'number') {
+      // Use a numeric threshold based on the absolute value: typically,
+      // if the absolute value is below 1e11, then it's a seconds timestamp.
+      // Otherwise, it's a milliseconds timestamp.
+      if (Math.abs(value) < 1e11) {
+        return 'dateSeconds';
+      } else {
+        return 'dateMillseconds';
+      }
+    }
+    else if(typeof value === 'string')
+    {
+      if(utcRegex.test(value) || offsetRegex.test(value) || (localRegex.test(value) && value.length > 10) || YYMMDDRegexSlash.test(value))
+      {
+        return 'dateCompleteDateString'
+      }
+      else if(YYMMDDRegexDash.test(value))
+      {
+        return 'dateIncompleteDayString'
+      }
+      else
+      {
+        errorMessage()
+      }
+    }
+    else
+    {
+      errorMessage()
+    }
+}