ohlcv-indicators 1.5.2 → 1.5.3

package/index.js

@@ -7,8 +7,10 @@ import { volumeProfile } from './src/studies/volumeProfile.js'
 import {crossPairs} from './src/studies/findCrosses.js'
 import { candles } from './src/studies/candles.js'
 import { orb } from './src/studies/orb.js'
+import { donchianChannels } from './src/moving-averages/donchianChannel.js'
 import {Big} from 'trading-signals';
 import { parseOhlcvToVertical } from './src/utilities/parsing-utilities.js'
+import { candlesStudies } from './src/studies/candleStudies.js'
 
 export default class OHLCV_INDICATORS {
     constructor({input, precision = false, ticker = 'undefined'}) {
@@ -205,4 +207,18 @@ export default class OHLCV_INDICATORS {
 
         return this       
     }
+    donchianChannels(period, offset)
+    {
+        const result = donchianChannels(this, period, offset)
+        Object.assign(this.indicators, result)
+
+        return this       
+    }
+    candlesStudies(period)
+    {
+        const result = candlesStudies(this, period)
+        Object.assign(this.indicators, result)
+
+        return this       
+    }   
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "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/donchianChannel.js

@@ -0,0 +1,61 @@
+export const donchianChannels = (main, period, offset) => {
+
+    const {verticalOhlcv, precision, len} = main
+    const {high, low} = verticalOhlcv
+
+    return getDonchianChannels(high, low, period, offset, precision, len)
+}
+
+export const getDonchianChannels = (high, low, period, offset, precision, 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)
+
+    const maxQueue = []
+    const minQueue = []
+
+    const avg = (precision) 
+        ? ((h, l) => (h.plus(l)).div(2))
+        : ((h, l) => (h + l) / 2)
+
+    for (let i = 0; i < len; i++) {
+
+        while (maxQueue.length && maxQueue[0] <= i - period) {
+            maxQueue.shift()
+        }
+        // Remove smaller values from the end
+        while (maxQueue.length && high[maxQueue[maxQueue.length - 1]] <= high[i]) {
+            maxQueue.pop()
+        }
+        maxQueue.push(i)
+
+        while (minQueue.length && minQueue[0] <= i - period) {
+            minQueue.shift()
+        }
+        while (minQueue.length && low[minQueue[minQueue.length - 1]] >= low[i]) {
+            minQueue.pop()
+        }
+
+        minQueue.push(i)
+
+        if (i >= period - 1) {
+            const upperValue = high[maxQueue[0]]
+            const lowerValue = low[minQueue[0]]
+            const basisValue = avg(upperValue, lowerValue)
+
+            const indexWithOffset = i + offset
+
+            if (indexWithOffset >= 0 && indexWithOffset < len) {
+                donchian_channel_upper[indexWithOffset] = upperValue
+                donchian_channel_lower[indexWithOffset] = lowerValue
+                donchian_channel_basis[indexWithOffset] = basisValue
+            }
+        }
+    }
+
+    return { 
+        donchian_channel_upper, 
+        donchian_channel_lower,
+        donchian_channel_basis 
+    }
+}

package/src/moving-averages/ema.js

@@ -48,6 +48,7 @@ export const getEMA = (data, size, precision) => {
   }
 
 
+
   return output
 
 }

package/src/studies/candleStudies.js

@@ -0,0 +1,116 @@
+import {SMA, FasterSMA} from 'trading-signals';
+
+export const candlesStudies = (main, period) => {
+
+    const {inputOhlcv, len} = main
+
+    const cols = getCandlesStudies(inputOhlcv, period, len)
+    return cols
+}
+
+const getCandlesStudies = (inputOhlcv, period = 20, len) => {
+
+    let getSize = (a, b) => Math.abs(a - b)
+
+    let candle_direction = new Array(len).fill(null)
+
+    //body
+    let candle_body_size = new Array(len).fill(null)
+    let candle_body_size_mean = new Array(len).fill(null)
+    let candle_body_size_label = new Array(len).fill(null)
+
+    //top
+    let candle_top_size_mean = new Array(len).fill(null)
+    let candle_top_size = new Array(len).fill(null)
+    let candle_top_size_label = new Array(len).fill(null)
+
+    //bottom
+    let candle_bottom_size_mean = new Array(len).fill(null)
+    let candle_bottom_size = new Array(len).fill(null)
+    let candle_bottom_size_label = new Array(len).fill(null)
+
+
+    //instances
+    let bodyInstance = new FasterSMA(period)
+    let topInstance = new FasterSMA(period)
+    let bottomInstance = new FasterSMA(period)
+
+
+    for(let x = 0; x < len; x++)
+    {
+        const {open, high, low, close} = inputOhlcv[x]
+        let bodySizeMean = null
+        let topSizeMean = null
+        let bottomSizeMean = null
+        const bodySize = getSize(open, close)
+        let topSize
+        let bottomSize
+        let candleDirection = (close > open) ? 'up' : 'down'
+
+        if(candleDirection === 'up')
+        {
+            topSize = getSize(high, close)
+            bottomSize = getSize(open, low)
+        }
+        else
+        {
+            topSize = getSize(high, open)
+            bottomSize = getSize(close, low)
+        }
+
+        bodyInstance.update(bodySize)
+        topInstance.update(topSize)
+        bottomInstance.update(bottomSize)
+
+        try
+        {
+            bodySizeMean = bodyInstance.getResult()
+            topSizeMean = topInstance.getResult()
+            bottomSizeMean = bottomInstance.getResult()
+        }
+        catch(err)
+        {
+            bodySizeMean = null
+        }
+
+        candle_direction[x] = candleDirection
+
+        //body
+        candle_body_size[x] = bodySize
+        candle_body_size_mean[x] = bodySizeMean
+        candle_body_size_label[x] = labelSize(bodySize, bodySizeMean)
+        
+        //top
+        candle_top_size[x] = topSize
+        candle_top_size_mean[x] = topSizeMean
+        candle_top_size_label[x] = labelSize(topSize, topSizeMean)
+        
+
+        //bottom
+        candle_bottom_size[x] = bottomSize
+        candle_bottom_size_mean[x] = bottomSizeMean
+        candle_bottom_size_label[x] = labelSize(bottomSize, bottomSizeMean)
+        
+    }
+
+    return {
+        candle_direction,
+        candle_body_size_mean,
+        candle_body_size,
+        candle_body_size_label,
+        candle_top_size_mean,
+        candle_top_size,
+        candle_top_size_label,
+        candle_bottom_size_mean,
+        candle_bottom_size,
+        candle_bottom_size_label
+    }
+}
+
+const labelSize = (value, mean) => {
+
+    if(value === null || mean === null) return null
+    if(value > mean * 1.25) return 'large'
+    else if(value < mean * 0.75) return 'small'
+    else return 'medium'
+}

package/src/studies/findCrosses.js

@@ -27,7 +27,6 @@ export const findCrosses = ({fast, slow, precision}) => {
         lt = (a, b) => a < b     
     }
 
-
     const state = new Array(dataLength).fill(null)
 
     for(let x = 0; x < dataLength; x++)
@@ -37,17 +36,32 @@ export const findCrosses = ({fast, slow, precision}) => {
         let value
 
         if(f === null || s === null) value = 'neutral'
-        else if(eq(f, s)) value = 'neutral'
+        else if(eq(f, s)){
+            if(gt(fast[x-1], slow[x-1]))
+            {
+                value = 'up'
+            }
+            else if(lt(fast[x-1], slow[x-1]))
+            {
+                value = 'down'
+            }
+            else
+            {
+                value = 'neutral'
+            }
+        }
         else if(gt(f, s)) value = 'up'
         else if(lt(f, s)) value = 'down'
 
         state[x] = value
     }
 
+
+
     const groups = groupConsecutiveValues(state)
     const groupLengths = groups.map(g => g.length)
 
-    //console.log(groups)
+    //console.log(JSON.stringify(groups))
 
     return groups.map((group, gIndex) => {
         let initialValue = groupLengths[gIndex]
@@ -124,26 +138,39 @@ export const crossPairs = (main, arr) => {
 
         const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
 
-        // Find and add crosses
+        //cross already exists
         if(verticalOhlcv[crossName])
         {
             const cross = verticalOhlcv[crossName]
-            c[countName] = splitCount(cross)
-            x[crossName] = cross            
+            x[crossName] = cross    
+            
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+            
         }
+        //cross created from 2 columns
         else if (verticalOhlcv[fast] && verticalOhlcv[slow]) {
 
             const cross = findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow], precision});
-
-            c[countName] = splitCount(cross)
             x[crossName] = cross
 
-        } else if (verticalOhlcv[fast] && slowNumArrCache[slow]) {
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+
+        }
+        //cross created from 1 column and an number
+        else if (verticalOhlcv[fast] && slowNumArrCache[slow]) {
             const cross = findCrosses({fast: verticalOhlcv[fast], slow: slowNumArrCache[slow], precision})
-            
-            c[countName] = splitCount(cross)
             x[crossName] = cross
 
+            if(typeof count !== 'undefined'){
+                c[countName] = splitCount(cross)
+            }
+
         } else {
             console.log(`Missing ohlcv properties for ${fast} or ${slow}`);
         }

package/src/utilities/parsing-utilities.js

@@ -12,18 +12,20 @@ export const parseOhlcvToVertical = (input, len, big) => {
             verticalOhlcv[key] = new Array(len)
         }
     }
+
+    for(let x = 0; x < len; x++)
+    {
+        const { open, high, low, close, volume, ...rest } = input[x]
+        verticalOhlcv.open[x] = big(open)
+        verticalOhlcv.high[x] = big(high)
+        verticalOhlcv.low[x] = big(low)
+        verticalOhlcv.close[x] = big(close)
+        verticalOhlcv.volume[x] = big(volume)
     
-    input.forEach(({ open, high, low, close, volume, ...rest }, index) => {
-        verticalOhlcv.open[index] = big(open)
-        verticalOhlcv.high[index] = big(high)
-        verticalOhlcv.low[index] = big(low)
-        verticalOhlcv.close[index] = big(close)
-        verticalOhlcv.volume[index] = big(volume)
-    
-        for (const key in rest) {
-            verticalOhlcv[key][index] = rest[key];
-        }
-    })
+        for (const [key, value] of Object.entries(rest)) {
+            verticalOhlcv[key][x] = value
+        }      
+    }
     
     return verticalOhlcv
 }