ohlcv-indicators 1.9.2 → 1.9.4

package/src/utilities/parsing-utilities.js

@@ -1,28 +1,62 @@
+import { rsi } from "../oscillators/rsi.js"
+import { sma } from "../moving-averages/sma.js"
+import { ema } from "../moving-averages/ema.js"
+import { macd } from "../moving-averages/macd.js"
+import { relativeVolume } from "../moving-averages/relativeVolume.js"
+import { donchianChannels } from "../moving-averages/donchianChannel.js"
+import { bollingerBands } from "../moving-averages/bollingerBands.js"
+import { volumeOscillator } from "../oscillators/volumeOscillator.js"
+import { candlesStudies } from "../studies/candleStudies.js"
+import { lag } from "../studies/lag.js"
+
+const indicatorFunctions = {
+    rsi,
+    sma,
+    ema,
+    macd,
+    relativeVolume,
+    donchianChannels,
+    bollingerBands,
+    volumeOscillator,
+    candlesStudies,
+    lag
+}
 
-
-
-//true if first row date starts with yyyy-mm-dd date
-const validateFirstDate = arr => arr[0].hasOwnProperty('date') && typeof arr[0].date === 'string' && /^\d{4}-\d{2}-\d{2}/.test(arr[0].date)
+const validateFirstDate = (arr) => arr[0].hasOwnProperty('date') && typeof arr[0].date === 'string' && /^\d{4}-\d{2}-\d{2}/.test(arr[0].date)
 
 export const defaultStudyOptions = {
-    midPriceOpenClose: false,
-    midPriceHighLow: false,
-    sessionIndex: false,
-    sessionIntradayIndex: false,
-    dayOfTheWeek: false,
-    dayOfTheMonth: false,
-    weekOfTheMonth: false
+    midPriceOpenClose: true,
+    midPriceHighLow: true,
+    sessionIndex: true,
+    sessionIntradayIndex: true,
+    dayOfTheWeek: true,
+    dayOfTheMonth: true,
+    weekOfTheMonth: true
 }
 
-export const parseOhlcvToVertical = (input, len, studyOptions) => {
+const getDateInfo = (dateString) => {
+    const date = new Date(dateString);
+    const day_of_the_week = date.getDay();
+    const day_of_the_month = date.getDate();
+    const firstDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1);
+    const dayOffset = firstDayOfMonth.getDay();
+    const week_of_the_month = Math.ceil((day_of_the_month + dayOffset) / 7);
 
+    return {
+        day_of_the_week,
+        day_of_the_month,
+        week_of_the_month
+    };
+}
+
+export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
+    const { len, studyOptions = {}, inputParams } = main
 
-    if(Boolean(studyOptions))
-    {
-        for(let k in studyOptions)
-        {
-            if(!defaultStudyOptions.hasOwnProperty(k))
-            {
+    if (studyOptions) {
+        const studyOptionKeys = Object.keys(studyOptions)
+        for (let i = 0; i < studyOptionKeys.length; i++) {
+            const k = studyOptionKeys[i]
+            if (!defaultStudyOptions.hasOwnProperty(k)) {
                 throw new Error(`Key ${k} not found in defaultStudyOptions. Available options: ${Object.keys(defaultStudyOptions).join(', ')}`)
             }
         }
@@ -38,170 +72,189 @@ export const parseOhlcvToVertical = (input, len, studyOptions) => {
         weekOfTheMonth
     } = studyOptions
 
-    let highMax
-    let lowMin
-    let volMax
-    let volMin
-
-
     const numberColsKeys = ['open', 'high', 'low', 'close', 'volume']
-
-    if(midPriceOpenClose)
-    {
-        numberColsKeys.push('mid_price_open_close')
-    }
-
-    if(midPriceHighLow)
-    {
-        numberColsKeys.push('mid_price_high_low')
-    }
+    if (midPriceOpenClose) numberColsKeys.push('mid_price_open_close')
+    if (midPriceHighLow)   numberColsKeys.push('mid_price_high_low')
 
     const numberColsKeysSet = new Set(numberColsKeys)
-    const verticalOhlcv = {}
-
-    // Initialize arrays for numerical columns
-    for (const key of numberColsKeys) {
-        verticalOhlcv[key] = new Array(len)
-    }
-
-    // Extract other keys and initialize their arrays
-    const inputKeys = Object.keys(input[0])
-    const otherKeys = []
+    const vert = main.verticalOhlcv
+
+    let isValidDate = false
+    if (startIndex === 0) {
+        // Fresh initialization
+        // Initialize arrays for numerical columns
+        for (let i = 0; i < numberColsKeys.length; i++) {
+            vert[numberColsKeys[i]] = new Array(len)
+        }
 
-    for (const key of inputKeys) {
-        if (!numberColsKeysSet.has(key)) {
-            verticalOhlcv[key] = new Array(len)
-            otherKeys.push(key)
+        // Extract other keys and initialize their arrays
+        const inputKeys = Object.keys(input[0])
+        const otherKeys = []
+        for (let i = 0; i < inputKeys.length; i++) {
+            const key = inputKeys[i]
+            if (!numberColsKeysSet.has(key)) {
+                vert[key] = new Array(len)
+                otherKeys.push(key)
+            }
         }
-    }
+        main.otherKeys = otherKeys
 
+        isValidDate = validateFirstDate(input)
 
-    let prevDateStr
-    let sessionIndexCount = 0
-    let sessionIntradayIndexCount = 0
-    const isValidDate = validateFirstDate(input)
+        if (isValidDate) {
+            if (sessionIndex) {
+                vert['session_index'] = new Array(len)
+            }
+            if (sessionIntradayIndex) {
+                vert['session_intraday_index'] = new Array(len)
+            }
+            if (dayOfTheWeek) {
+                vert['day_of_the_week'] = new Array(len)
+            }
+            if (dayOfTheMonth) {
+                vert['day_of_the_month'] = new Array(len)
+            }
+            if (weekOfTheMonth) {
+                vert['week_of_the_month'] = new Array(len)
+            }
 
-    if(isValidDate)
-    {
-        if(sessionIndex)
-        {
-            verticalOhlcv['session_index'] = new Array(len)
+            main.prevDateStr = input[0].date.slice(0, 10)
+            main.sessionIndexCount = 0
+            main.sessionIntradayIndexCount = 0
+            main.cachedDayInfo = getDateInfo(main.prevDateStr)
+        } else {
+            // If no valid date, ensure these are null
+            main.prevDateStr = null
+            main.sessionIndexCount = null
+            main.sessionIntradayIndexCount = null
+            main.cachedDayInfo = null
         }
-        
-        if(sessionIntradayIndex)
-        {
-            verticalOhlcv['session_intraday_index'] = new Array(len)
+    } else {
+        // startIndex > 0
+        // We assume arrays and keys are already set
+        if (!main.otherKeys) {
+            throw new Error("otherKeys not found in main. Ensure you run with startIndex=0 first to initialize.")
         }
-        
-        if(dayOfTheWeek)
-        {
-            verticalOhlcv['day_of_the_week'] = new Array(len)
-        }
-        
-        if(dayOfTheMonth)
-        {
-            verticalOhlcv['day_of_the_month'] = new Array(len)
+
+        // Validate that state variables needed are present
+        if (!main.hasOwnProperty('prevDateStr')) {
+            throw new Error("prevDateStr missing in main. Make sure to store state after initial run.")
         }
-        
-        if(weekOfTheMonth)
-        {
-            verticalOhlcv['week_of_the_month'] = new Array(len)
+
+        // If we had a valid date initially, we continue with date computations
+        isValidDate = main.prevDateStr !== null
+    }
+
+    // Pre-process indicator params
+    const indicatorCalls = []
+    if (inputParams && typeof inputParams === 'object') {
+        for (const key in inputParams) {
+            if (key === 'crossPairs') continue
+            const technical = inputParams[key]
+            if (Array.isArray(technical)) {
+                for (let i = 0; i < technical.length; i++) {
+                    const params = technical[i];
+                    if (Array.isArray(params)) {
+                        indicatorCalls.push({
+                            fn: indicatorFunctions[key],
+                            args: params
+                        })
+                    }
+                }
+            }
         }
-        
-        prevDateStr = input[0].date.slice(0, 10)
     }
-    
-    for (let x = 0; x < len; x++) {
-        const current = input[x]
 
+    // Store references for numeric arrays to avoid repeated dictionary lookups
+    const vo_open = vert.open
+    const vo_high = vert.high
+    const vo_low = vert.low
+    const vo_close = vert.close
+    const vo_volume = vert.volume
+    const vo_mid_oc = midPriceOpenClose ? vert.mid_price_open_close : null
+    const vo_mid_hl = midPriceHighLow ? vert.mid_price_high_low : null
+
+    // References for other keys arrays
+    const otherArrays = {}
+    for (let i = 0; i < main.otherKeys.length; i++) {
+        const k = main.otherKeys[i]
+        otherArrays[k] = vert[k]
+    }
+
+    // For date/session logic, use previously stored state if startIndex > 0
+    let prevDateStr = main.prevDateStr
+    let sessionIndexCount = main.sessionIndexCount
+    let sessionIntradayIndexCount = main.sessionIntradayIndexCount
+    let cachedDayInfo = main.cachedDayInfo
 
-        verticalOhlcv.open[x] = current.open
-        verticalOhlcv.high[x] = current.high
-        verticalOhlcv.low[x] = current.low
-        verticalOhlcv.close[x] = current.close
-        verticalOhlcv.volume[x] = current.volume
+    // Compute indicators and fill data from startIndex to len
+    for (let x = startIndex; x < len; x++) {
+        const current = input[x]
 
-        if(midPriceOpenClose)
-        {
-            verticalOhlcv.mid_price_open_close[x] = (current.open + current.close) / 2
+        // Assign OHLCV
+        vo_open[x] = current.open
+        vo_high[x] = current.high
+        vo_low[x] = current.low
+        vo_close[x] = current.close
+        vo_volume[x] = current.volume
+
+        // Run indicator functions
+        for (let i = 0; i < indicatorCalls.length; i++) {
+            const { fn, args } = indicatorCalls[i]
+            fn(main, x, ...args)
         }
 
-        if(midPriceHighLow)
-        {
-            verticalOhlcv.mid_price_high_low[x] = (current.high + current.low) / 2
+        // Mid-price calculations
+        if (vo_mid_oc) {
+            vo_mid_oc[x] = (current.open + current.close) / 2
         }
-       
-        // Process other keys
-        for (const key of otherKeys) {
-            verticalOhlcv[key][x] = current[key]
+        if (vo_mid_hl) {
+            vo_mid_hl[x] = (current.high + current.low) / 2
         }
 
-        // Date processing for session indices
+        // Other keys
+        for (let i = 0; i < main.otherKeys.length; i++) {
+            const k = main.otherKeys[i]
+            otherArrays[k][x] = current[k]
+        }
+
+        // Date processing for session indices and date fields
         if (isValidDate) {
             const thisDateStr = current.date.slice(0, 10)
-
             if (thisDateStr !== prevDateStr) {
                 prevDateStr = thisDateStr
                 sessionIndexCount++
                 sessionIntradayIndexCount = 0
+                cachedDayInfo = getDateInfo(thisDateStr)
             }
 
-            const {
-                day_of_the_week,
-                day_of_the_month,
-                week_of_the_month
-            } = getDateInfo(thisDateStr)
-
-            if(dayOfTheWeek)
-            {
-                verticalOhlcv.day_of_the_week[x] = day_of_the_week
+            if (dayOfTheWeek) {
+                vert.day_of_the_week[x] = cachedDayInfo.day_of_the_week
             }
-            
-            if(dayOfTheMonth)
-            {
-                verticalOhlcv.day_of_the_month[x] = day_of_the_month
+
+            if (dayOfTheMonth) {
+                vert.day_of_the_month[x] = cachedDayInfo.day_of_the_month
             }
-            
-            if(weekOfTheMonth)
-            {
-                verticalOhlcv.week_of_the_month[x] = week_of_the_month
+
+            if (weekOfTheMonth) {
+                vert.week_of_the_month[x] = cachedDayInfo.week_of_the_month
             }
 
-            if(sessionIndex)
-            {
-                verticalOhlcv.session_index[x] = sessionIndexCount
+            if (sessionIndex) {
+                vert.session_index[x] = sessionIndexCount
             }
-            
-            if(sessionIntradayIndex)
-            {
-                verticalOhlcv.session_intraday_index[x] = sessionIntradayIndexCount
+
+            if (sessionIntradayIndex) {
+                vert.session_intraday_index[x] = sessionIntradayIndexCount
             }
 
             sessionIntradayIndexCount++
         }
     }
 
-    return verticalOhlcv
+    // Store current state so that we can continue from here in subsequent calls
+    main.prevDateStr = prevDateStr
+    main.sessionIndexCount = sessionIndexCount
+    main.sessionIntradayIndexCount = sessionIntradayIndexCount
+    main.cachedDayInfo = cachedDayInfo
 }
-
-
-const getDateInfo = dateString => {
-    const date = new Date(dateString);
-  
-    // Get day of the week (0 for Sunday, 1 for Monday, etc.)
-    const day_of_the_week = date.getDay()
-  
-    // Get day of the month
-    const day_of_the_month = date.getDate();
-  
-    // Calculate the week of the month
-    const firstDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1);
-    const dayOffset = firstDayOfMonth.getDay(); // Day of the week for the 1st day of the month
-    const week_of_the_month = Math.ceil((day_of_the_month + dayOffset) / 7);
-  
-    return {
-        day_of_the_week,
-        day_of_the_month,
-        week_of_the_month
-    };
-  }

package/src/utilities/setIndicatorsFromInputParams.js

@@ -38,8 +38,6 @@ export const setIndicatorsFromInputParams = ({ input, inputParams, OHLCV_INDICAT
             }
         }
     }
-
-    console.log(indicators.getLastValues());
-
+    
     return indicators;
 };

package/src/oscillators/orb.js

@@ -1,41 +0,0 @@
-import { findCrosses } from "../studies/findCrosses.js"
-
-export const orb = main => {
-    const {inputOhlcv, len} = main
-    const cols = getOrbOfTheFirstCandle(inputOhlcv, len)
-    return cols
-}
-
-const getOrbOfTheFirstCandle = (inputOhlcv, len) => {
-    const orb_high = new Array(len).fill(0)
-    const orb_low = new Array(len).fill(0)
-    let startIndex = 0
-    let currentDate = null
-    let firstCandleHigh = 0
-    let firstCandleLow = 0
-
-    for (let i = 0; i < len; i++) {
-        const current = inputOhlcv[i]
-
-        if(i === 0){
-            if(!current.hasOwnProperty('date'))
-            {
-                throw Error(`input ohlcv array must have a date property available in candle datapoint`)
-            }
-        }
-
-        const date = current.date.split(' ')[0]
-
-        if (date !== currentDate) {
-            currentDate = date;
-            firstCandleHigh = current.high
-            firstCandleLow = current.low
-        }
-
-        orb_high[startIndex] = firstCandleHigh
-        orb_low[startIndex] = firstCandleLow
-        startIndex++
-    }
-
-    return {orb_high, orb_low}
-}