ohlcv-indicators 1.5.7 → 1.6.0

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.5.7",
+  "version": "1.6.0",
   "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",
   "scripts": {
     "test": "node test/test.js",
     "study": "node test/study.js",
+    "knn": "node test/knn.js",
     "build": "npx webpack"
   },
   "author": "https://jaimelias.com/",
   "license": "ISC",
   "dependencies": {
+    "ml-knn": "^3.0.0",
     "trading-signals": "^5.0.4"
   },
   "devDependencies": {

package/src/moving-averages/bollingerBands.js

@@ -3,14 +3,14 @@ import {BollingerBands, FasterBollingerBands, Big} from 'trading-signals';
 
 export const bollingerBands = (main, size, times) => {
 
-  const {verticalOhlcv, precision} = main
+  const {verticalOhlcv} = main
   const {close} = verticalOhlcv
 
-  const col = getBollingerBands(close, size, times, precision)
+  const col = getBollingerBands(close, size, times)
   return col
 }
 
-export const getBollingerBands = (data, size = 20, times = 2, precision) => {
+export const getBollingerBands = (data, size = 20, times = 2) => {
   
   const dataLength = data.length
   const bollinger_bands_upper =  Array(dataLength).fill(null)
@@ -21,22 +21,12 @@ export const getBollingerBands = (data, size = 20, times = 2, precision) => {
   let range = null
   let height = null
 
-  let getRange
-  let instance
+  let getRange = (value, upper, lower) => ({
+    range: ((value - lower) / (upper - lower)) * 100,
+    height: ((upper-lower)/lower) * 100
+  })
+  let instance = new FasterBollingerBands(size, times)
 
-  if (precision) {
-    instance = new BollingerBands(size, times)
-    getRange = (value, upper, lower) => ({
-      range: ((value.minus(lower)).div((upper.minus(lower)))).times(100),
-      height: ((upper.minus(lower)).div(lower)).times(100)
-    })
-  } else {
-    instance = new FasterBollingerBands(size, times)
-    getRange = (value, upper, lower) => ({
-      range: ((value - lower) / (upper - lower)) * 100,
-      height: ((upper-lower)/lower) * 100
-    })
-  }
   
   for (let x = 0; x < dataLength; x++) {
     let obj = {};

package/src/moving-averages/donchianChannel.js

@@ -1,12 +1,12 @@
 export const donchianChannels = (main, period, offset) => {
 
-    const {verticalOhlcv, precision, len} = main
+    const {verticalOhlcv, len} = main
     const {high, low} = verticalOhlcv
 
-    return getDonchianChannels(high, low, period, offset, precision, len)
+    return getDonchianChannels(high, low, period, offset, len)
 }
 
-export const getDonchianChannels = (high, low, period, offset, precision, len) => {
+export const getDonchianChannels = (high, low, period, offset, len) => {
     const donchian_channel_upper = new Array(len).fill(null)
     const donchian_channel_lower = new Array(len).fill(null)
     const donchian_channel_basis = new Array(len).fill(null)
@@ -14,10 +14,8 @@ export const getDonchianChannels = (high, low, period, offset, precision, len) =
     const maxQueue = []
     const minQueue = []
 
-    const avg = (precision) 
-        ? ((h, l) => (h.plus(l)).div(2))
-        : ((h, l) => (h + l) / 2)
-
+    const avg = ((h, l) => (h + l) / 2)
+    
     for (let i = 0; i < len; i++) {
 
         while (maxQueue.length && maxQueue[0] <= i - period) {

package/src/moving-averages/ema.js

@@ -3,27 +3,27 @@ import {EMA, FasterEMA} from 'trading-signals'
 
 export const ema = (main, size) => {
 
-  const {verticalOhlcv, precision} = main
+  const {verticalOhlcv} = main
   const {close} = verticalOhlcv
 
-  const col = getEMA(close, size, precision)
+  const col = getEMA(close, size)
 
   return {
     [`ema_${size}`]: col
   }
 }
 
-export const getEMA = (data, size, precision) => {
+export const getEMA = (data, size) => {
   
 
-  if(typeof precision === 'undefined' || typeof data === 'undefined' || typeof size === 'undefined')
+  if(typeof data === 'undefined' || typeof size === 'undefined')
   {
     throw Error('undefined param in getEMA')
   }
 
   const dataLength = data.length
   const output = new Array(dataLength).fill(null)
-  const instance = (precision) ? new EMA(size) : new FasterEMA(size)
+  const instance = new FasterEMA(size)
 
   for(let x = 0; x < dataLength; x++)
   {

package/src/moving-averages/macd.js

@@ -4,26 +4,21 @@ import {EMA, MACD, FasterEMA, FasterMACD} from 'trading-signals';
 
 export const macd = (main, fastLine, slowLine, signalLine) => {
 
-    const {verticalOhlcv, precision} = main
+    const {verticalOhlcv} = main
     const {close} = verticalOhlcv
-    const col = getMACD(close, fastLine, slowLine, signalLine, precision)
+    const col = getMACD(close, fastLine, slowLine, signalLine)
 
     return col
 }
 
-export const getMACD = (data, fastLine = 12, slowLine = 26, signalLine = 9, precision) => {
+export const getMACD = (data, fastLine = 12, slowLine = 26, signalLine = 9) => {
 
     const dataLength = data.length
     const diff = new Array(dataLength).fill(null)
     const dea = new Array(dataLength).fill(null)
     const histogram = new Array(dataLength).fill(null)
 
-    const instance = (precision) ? new MACD({
-        indicator: EMA,
-        shortInterval: fastLine,
-        longInterval: slowLine,
-        signalInterval: signalLine
-    }) : new FasterMACD(new FasterEMA(fastLine), new FasterEMA(slowLine), new FasterEMA(signalLine))
+    const instance = new FasterMACD(new FasterEMA(fastLine), new FasterEMA(slowLine), new FasterEMA(signalLine))
 
     for(let x = 0; x < dataLength; x++)
     {
@@ -44,7 +39,7 @@ export const getMACD = (data, fastLine = 12, slowLine = 26, signalLine = 9, prec
         histogram[x] = obj.histogram
     }
 
-    const x = findCrosses({fast: diff, slow: dea, precision})
+    const x = findCrosses({fast: diff, slow: dea})
 
 	return {
 		macd_diff: diff, 

package/src/moving-averages/sma.js

@@ -3,27 +3,26 @@ import {SMA, FasterSMA} from 'trading-signals';
 
 export const sma = (main, size) => {
 
-  const {verticalOhlcv, precision} = main
+  const {verticalOhlcv} = main
   const {close} = verticalOhlcv
 
-  const col = getSMA(close, size, precision)
+  const col = getSMA(close, size)
  
   return {
     [`sma_${size}`]: col
   }
 }
 
-export const getSMA = (data, size, precision) => {
+export const getSMA = (data, size) => {
   
-  if(typeof precision === 'undefined' || typeof data === 'undefined' || typeof size === 'undefined')
+  if(typeof data === 'undefined' || typeof size === 'undefined')
   {
     throw Error('undefined param in getSMA')
   }
 
   const dataLength = data.length
   const output = new Array(dataLength).fill(null)
-  const instance = (precision) ? new SMA(size) : new FasterSMA(size)
-  
+  const instance = new FasterSMA(size)
 
   for(let x = 0; x < dataLength; x++)
   {

package/src/{studies → oscillators}/orb.js

@@ -1,13 +1,12 @@
-import { findCrosses } from "./findCrosses.js"
+import { findCrosses } from "../studies/findCrosses.js"
 
 export const orb = main => {
-    const {inputOhlcv, len, precision, verticalOhlcv} = main
-    const {close} = verticalOhlcv
-    const cols = getOrbOfTheFirstCandle(inputOhlcv, close, len, precision)
+    const {inputOhlcv, len} = main
+    const cols = getOrbOfTheFirstCandle(inputOhlcv, len)
     return cols
 }
 
-const getOrbOfTheFirstCandle = (inputOhlcv, close, len, precision) => {
+const getOrbOfTheFirstCandle = (inputOhlcv, len) => {
     const orb_high = new Array(len).fill(0)
     const orb_low = new Array(len).fill(0)
     let startIndex = 0

package/src/oscillators/rsi.js

@@ -7,7 +7,7 @@ const ma = {getSMA, getEMA}
 
 export const rsi = (main, period, movingAverage, movingAveragePeriod) => {
 
-    const {verticalOhlcv, precision} = main
+    const {verticalOhlcv} = main
     const {close} = verticalOhlcv
 
     if(typeof period === 'number' && typeof movingAveragePeriod === 'undefined')
@@ -15,12 +15,12 @@ export const rsi = (main, period, movingAverage, movingAveragePeriod) => {
         movingAveragePeriod = period
     }
 
-    const col = getRSI(close, period, movingAverage, movingAveragePeriod, precision)
+    const col = getRSI(close, period, movingAverage, movingAveragePeriod)
 
     return col   
 }
 
-export const getRSI = (data, period = 14, movingAverage = 'SMA', movingAveragePeriod = 14, precision) => {
+export const getRSI = (data, period = 14, movingAverage = 'SMA', movingAveragePeriod = 14) => {
 
     const dataLength = data.length
 
@@ -29,7 +29,7 @@ export const getRSI = (data, period = 14, movingAverage = 'SMA', movingAveragePe
     }
 
     let rsi = new Array(dataLength).fill(null)
-    const instance = (precision) ? new RSI(period) : new FasterRSI(period)
+    const instance = new FasterRSI(period)
 
     for(let x = 0; x < dataLength; x++)
     {
@@ -58,9 +58,9 @@ export const getRSI = (data, period = 14, movingAverage = 'SMA', movingAveragePe
     {
         if(ma.hasOwnProperty(`get${movingAverage}`))
         {
-            const rsi_smoothed = ma[`get${movingAverage}`](rsi, movingAveragePeriod, precision)
+            const rsi_smoothed = ma[`get${movingAverage}`](rsi, movingAveragePeriod)
             output[`rsi_${movingAverage}_${movingAveragePeriod}`] = rsi_smoothed
-            output[`rsi_${period}_x_rsi_${movingAverage}_${movingAveragePeriod}`] = findCrosses({fast: rsi, slow: rsi_smoothed, precision})
+            output[`rsi_${period}_x_rsi_${movingAverage}_${movingAveragePeriod}`] = findCrosses({fast: rsi, slow: rsi_smoothed})
         }
     }
 

package/src/studies/candleStudies.js

@@ -28,13 +28,16 @@ const getCandlesStudies = (inputOhlcv, period = 20, len) => {
 
     //instances
     let bodyInstance = new FasterSMA(period)
+    let gapInstance = new FasterSMA(parseInt(period/2))
 
     for(let x = 0; x < len; x++)
     {
-        const prev = inputOhlcv[x-1]
         const {open, high, low, close} = inputOhlcv[x]
-        const gapSize = (typeof prev !== 'undefined') ? Math.abs(prev.close - open) : null
+        const gapSize = (typeof inputOhlcv[x-1] !== 'undefined') 
+            ? calculateHighLowEmptyGaps(inputOhlcv[x], inputOhlcv[x-1]) 
+            : null
         let bodySizeMean = null
+        let gapSizeMean = null
         const bodySize = getSize(open, close)
         let topSize
         let bottomSize
@@ -53,28 +56,36 @@ const getCandlesStudies = (inputOhlcv, period = 20, len) => {
 
         bodyInstance.update(bodySize)
 
+        if(gapSize)
+        {
+            gapInstance.update(gapSize)
+        }
+        
+
         try
         {
             bodySizeMean = bodyInstance.getResult()
+            gapSizeMean = gapInstance.getResult()
         }
         catch(err)
         {
             bodySizeMean = null
+            gapSizeMean = null
         }
 
         candle_direction[x] = candleDirection
 
         //body
-        candle_body_size[x] = classifySize(bodySize, bodySizeMean)
+        candle_body_size[x] = classifySize(bodySize, bodySizeMean, 0.25)
         
         //top
-        candle_top_size[x] = classifySize(topSize, bodySizeMean)
+        candle_top_size[x] = classifySize(topSize, bodySizeMean, 0.25)
         
         //bottom
-        candle_bottom_size[x] = classifySize(bottomSize, bodySizeMean)
+        candle_bottom_size[x] = classifySize(bottomSize, bodySizeMean, 0.25)
 
         //gap
-        candle_gap_size[x] = classifySize(gapSize, bodySizeMean)
+        candle_gap_size[x] = classifySize(gapSize, gapSizeMean, 0.25)
     }
 
     return {
@@ -88,10 +99,46 @@ const getCandlesStudies = (inputOhlcv, period = 20, len) => {
 
 
 // 1 for large, 0.5 for medium and 0 for small
-const classifySize = (value, mean) => {
+const classifySize = (value, mean, number = 0.25) => {
 
     if(value === null || mean === null) return null
-    if(value > mean * 1.25) return 1
-    else if(value < mean * 0.75) return 0
-    else return 0.5
+    if(value > mean * (number*5)) return 1
+    else if(value < mean * (number*3)) return 0
+    else return number * 2
+}
+
+const calculateHighLowEmptyGaps = (current, prev) => {
+    // This function calculates the empty gaps between the current high/low and the previous high/low.
+    // Gaps are zones where the highest highs and lowest lows of the previous and current candles do not touch.
+    // If any of the values overlap, the gapSize is 0.
+
+    if (!prev) return null; // No previous candle, so no gap
+
+    const {open, high, low, close } = current;
+    const { high: prevHigh, low: prevLow } = prev;
+
+    const highs = [high, prevHigh]
+    const lows = [low, prevLow]
+
+
+    if(close > open)
+    {
+        highs.push(close)
+        lows.push(open)
+    }
+    else
+    {
+        highs.push(open)
+        lows.push(close)        
+    }
+
+
+    const maxHigh = Math.max(high, prevHigh)
+    const minLow = Math.min(low, prevLow)
+    const fullSize = maxHigh - minLow
+    const prevSize = Math.abs(prevHigh - prevLow)
+    const currentSize = Math.abs(high-low)
+    const gapSize = fullSize - (prevSize+currentSize)
+
+    return (gapSize > 0) ? gapSize : 0.01
 }

package/src/studies/findCrosses.js

@@ -1,6 +1,10 @@
+const eq = (a, b) => a === b
+const gt = (a, b) => a > b
+const lt = (a, b) => a < b
+
 
 // Function to find crosses between two arrays: fast and slow
-export const findCrosses = ({fast, slow, precision}) => {
+export const findCrosses = ({fast, slow}) => {
     // Map states based on comparison of fast and slow arrays
 
     const dataLength = fast.length
@@ -10,23 +14,6 @@ export const findCrosses = ({fast, slow, precision}) => {
         throw Error('fast and slow do not have the same length')
     }
 
-    let eq
-    let gt
-    let lt
-
-    if(precision)
-    {
-        eq = (a, b) => a.eq(b)
-        gt = (a, b) => a.gt(b)
-        lt = (a, b) => a.lt(b)
-    }
-    else
-    {
-        eq = (a, b) => a === b
-        gt = (a, b) => a > b
-        lt = (a, b) => a < b     
-    }
-
     const state = new Array(dataLength).fill(null)
 
     for(let x = 0; x < dataLength; x++)
@@ -39,19 +26,19 @@ export const findCrosses = ({fast, slow, precision}) => {
         else if(eq(f, s)){
             if(gt(fast[x-1], slow[x-1]))
             {
-                value = 'up'
+                value = 1 //up
             }
             else if(lt(fast[x-1], slow[x-1]))
             {
-                value = 'down'
+                value = 0 //down
             }
             else
             {
-                value = 'neutral'
+                value = 0.5 //neutral
             }
         }
-        else if(gt(f, s)) value = 'up'
-        else if(lt(f, s)) value = 'down'
+        else if(gt(f, s)) value = 1
+        else if(lt(f, s)) value = 0
 
         state[x] = value
     }
@@ -59,9 +46,14 @@ export const findCrosses = ({fast, slow, precision}) => {
 
 
     const groups = groupConsecutiveValues(state)
-    const groupLengths = groups.map(g => g.length)
 
-    //console.log(JSON.stringify(groups))
+    return flatGroupsToNumArr(groups)
+}
+
+
+const flatGroupsToNumArr = groups => {
+
+    const groupLengths = groups.map(g => g.length)
 
     return groups.map((group, gIndex) => {
         let initialValue = groupLengths[gIndex]
@@ -69,15 +61,15 @@ export const findCrosses = ({fast, slow, precision}) => {
         return group.map((s, i) => {
             let v = initialValue - i
 
-            if(s === 'neutral')
+            if(s === 0.5)
             {
                 v = 0
             }
-            if(s === 'up')
+            if(s === 1)
             {
                 v = v * 1
             }
-            if(s === 'down')
+            if(s === 0)
             {
                 v = v * -1
             }
@@ -85,11 +77,11 @@ export const findCrosses = ({fast, slow, precision}) => {
             return v
         }).reverse()
     }).flat()
-
 }
 
+
 // Helper function to group consecutive values
-const groupConsecutiveValues = arr => {
+export const groupConsecutiveValues = arr => {
     if (arr.length === 0) return []
 
     return arr.reduce((acc, currentValue, index, array) => {
@@ -118,7 +110,7 @@ const groupConsecutiveValues = arr => {
 
 export const crossPairs = (main, arr) => {
 
-    const {verticalOhlcv, precision, big, len} = main
+    const {verticalOhlcv, len} = main
     const slowNumArrCache = {};
     const x = {}
     const c = {}
@@ -130,7 +122,7 @@ export const crossPairs = (main, arr) => {
         // Prepare slowNumArr if 'slow' is a number
         if (typeof slow === 'number' && !slowNumArrCache[slow]) {
 
-            slowNumArrCache[slow] = Array(len).fill(big(slow))
+            slowNumArrCache[slow] = Array(len).fill(slow)
         }
     
         const crossName = `${fast}_x_${slow}`
@@ -153,7 +145,7 @@ export const crossPairs = (main, arr) => {
         //cross created from 2 columns
         else if (verticalOhlcv[fast] && verticalOhlcv[slow]) {
 
-            const cross = findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow], precision});
+            const cross = findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow]});
             x[crossName] = cross
 
             if(typeof count !== 'undefined')
@@ -164,7 +156,7 @@ export const crossPairs = (main, arr) => {
         }
         //cross created from 1 column and an number
         else if (verticalOhlcv[fast] && slowNumArrCache[slow]) {
-            const cross = findCrosses({fast: verticalOhlcv[fast], slow: slowNumArrCache[slow], precision})
+            const cross = findCrosses({fast: verticalOhlcv[fast], slow: slowNumArrCache[slow]})
             x[crossName] = cross
 
             if(typeof count !== 'undefined'){
@@ -177,4 +169,54 @@ export const crossPairs = (main, arr) => {
     }
 
     return {x, c}
+}
+
+
+export const findLinearDirection = (main, keyName) => {
+ 
+    const {verticalOhlcv} = main
+
+    if(!verticalOhlcv.hasOwnProperty(keyName)) throw Error(`property ${keyName} not found in verticalOhlcv. Invoked by findDirectionCross.`)
+
+    const arr = verticalOhlcv[keyName]
+    const len = arr.length
+    const state = new Array(len).fill(null)
+
+   
+    for(let x = 0; x < len; x++)
+    {
+        if(x > 0 && arr[x] !== null)
+        {
+            let curr = arr[x]
+            let prev = arr[x-1]
+
+            if(gt(curr, prev))
+            {
+                state[x] = 1 //up
+            }
+            else if(lt(curr, prev))
+            {
+                state[x] = 0 //down
+            }
+            else
+            {
+                state[x] = 0.5 //neutral
+            }
+        }
+    }
+
+    return state
+}
+
+export const findDirectionCross = (main, keyName) => {
+
+
+    const {verticalOhlcv} = main
+
+    if(!verticalOhlcv.hasOwnProperty(keyName)) throw Error(`property ${keyName} not found in verticalOhlcv. Invoked by findDirectionCross.`)
+
+    const state = findLinearDirection(main, keyName)
+    const groups = groupConsecutiveValues(state)
+
+    return flatGroupsToNumArr(groups)
 }

package/src/utilities/parsing-utilities.js

@@ -1,7 +1,7 @@
 //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)
 
-export const parseOhlcvToVertical = (input, len, big) => {
+export const parseOhlcvToVertical = (input, len) => {
     const numberColsKeys = ['open', 'high', 'low', 'close', 'volume']
     const numberColsKeysSet = new Set(numberColsKeys)
     const verticalOhlcv = {}
@@ -38,12 +38,11 @@ export const parseOhlcvToVertical = (input, len, big) => {
     for (let x = 0; x < len; x++) {
         const current = input[x]
 
-        // Process numerical columns with 'big' function
-        verticalOhlcv.open[x] = big(current.open)
-        verticalOhlcv.high[x] = big(current.high)
-        verticalOhlcv.low[x] = big(current.low)
-        verticalOhlcv.close[x] = big(current.close)
-        verticalOhlcv.volume[x] = big(current.volume)
+        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
 
         // Process other keys
         for (const key of otherKeys) {
@@ -67,8 +66,4 @@ export const parseOhlcvToVertical = (input, len, big) => {
     }
 
     return verticalOhlcv
-}
-
-
-
-
+}