ohlcv-indicators 1.8.7 → 1.8.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.8.7",
+  "version": "1.8.9",
   "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/vwap.js

@@ -0,0 +1,40 @@
+
+
+export const vwap = (main) => {
+    const { verticalOhlcv } = main;
+    
+    const vwapValues = calculateVWAP(verticalOhlcv);
+
+    return {
+        [`vwap`]: vwapValues,
+    };
+};
+
+const calculateVWAP = data => {
+    const { high, low, close, volume } = data;
+    const output = new Array(close.length).fill(null)
+
+    // Cumulative sums for VWAP calculation
+    let cumulativePriceVolume = 0;
+    let cumulativeVolume = 0;
+
+    for (let x = 0; x < close.length; x++) {
+
+        const typicalPrice = (high[x] + low[x] + close[x]) / 3;
+
+        // Calculate Price * Volume for this interval
+        const priceVolume = typicalPrice * volume[x];
+
+        // Update cumulative sums
+        cumulativePriceVolume += priceVolume;
+        cumulativeVolume += volume[x];
+
+        // Calculate VWAP for this interval
+        const vwap = cumulativePriceVolume / cumulativeVolume;
+
+        // Push the VWAP value into the array
+        output[x] = vwap
+    }
+
+    return output
+}

package/src/studies/candleStudies.js

@@ -19,8 +19,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
     let candle_bottom_size = new Array(len).fill(null) //scaled bottom size(0, 0.5 and 1)
     let candle_gap_size = new Array(len).fill(null) //scaled gap between the current open and previous close (-1 to 1)
     let candle_shadow_size = new Array(len).fill(null) //scaled shadow size high - slow
-    let candle_position =  new Array(len).fill(null) //scaled shadow size curr.close - prev.close
-
+    let candle_close_direction =  new Array(len).fill(null) //scaled shadow size curr.close - prev.close
+    let candle_high_direction = new Array(len).fill(null) //scaled shadow size curr.high - prev.high
+    let candle_low_direction = new Array(len).fill(null) //scaled shadow size curr.low - prev.low
+    let candle_open_direction = new Array(len).fill(null) //scaled shadow size curr.open - prev.open
 
     //instances
     let topInstance 
@@ -28,7 +30,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
     let gapInstance
     let bodySizeInstance
     let shadowSizeInstance
-    let positionInstance
+    let closeDirectionInstance
+    let highDirectionInstance
+    let lowDirectionInstance
+    let openDirectionInstance
 
     if(classify)
     {
@@ -37,7 +42,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         gapInstance = new FasterSMA(period)
         bodySizeInstance = new FasterSMA(period)
         shadowSizeInstance = new FasterSMA(period)
-        positionInstance = new FasterSMA(period)
+        closeDirectionInstance = new FasterSMA(period)
+        highDirectionInstance = new FasterSMA(period)
+        lowDirectionInstance = new FasterSMA(period)
+        openDirectionInstance = new FasterSMA(period)
     }
 
     for(let x = 0; x < len; x++)
@@ -45,10 +53,7 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         const curr = inputOhlcv[x]
         const prev = inputOhlcv[x-1]
 
-        if(typeof prev === 'undefined')
-        {
-            continue
-        }
+        if(typeof prev === 'undefined') continue
 
         const {open, high, low, close} = curr
 
@@ -59,7 +64,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         let topSizeMean = null
         let bodySizeMean = null
         let shadowSizeMean = null
-        let positionMean = null
+        let closeDirectionMean = null
+        let highDirectionMean = null
+        let lowDirectionMean = null
+        let openDirectionMean = null
 
         //directions
         const isUp = close > open
@@ -70,7 +78,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         const topSize = high - Math.max(open, close)
         const bottomSize = Math.min(open, close) - low
         const gapSize = Math.abs(prev.close - curr.open)
-        const position = Math.abs(curr.close - prev.close)
+        const closeDirection = Math.abs(curr.close - prev.close)
+        const highDirection = Math.abs(curr.high - prev.high)
+        const lowDirection = Math.abs(curr.low - prev.low)
+        const openDirection = Math.abs(curr.open - prev.open)
 
         if(classify)
         {
@@ -81,8 +92,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
 
             gapInstance.update(gapSize)
             bodySizeInstance.update(candleBodySize)
-            positionInstance.update(position)
-            
+            closeDirectionInstance.update(closeDirection)
+            highDirectionInstance.update(highDirection)
+            lowDirectionInstance.update(lowDirection)
+            openDirectionInstance.update(openDirection)
             
             try
             {
@@ -91,7 +104,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
                 gapMean = gapInstance.getResult()
                 bodySizeMean = bodySizeInstance.getResult()
                 shadowSizeMean = shadowSizeInstance.getResult()
-                positionMean = positionInstance.getResult()
+                closeDirectionMean = closeDirectionInstance.getResult()
+                highDirectionMean = highDirectionInstance.getResult()
+                lowDirectionMean = lowDirectionInstance.getResult()
+                openDirectionMean = openDirectionInstance.getResult()
             }
             catch(err)
             {
@@ -100,7 +116,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
                 topSizeMean = null
                 bottomSizeMean = null
                 shadowSizeMean = null
-                positionMean = null
+                closeDirectionMean = null
+                highDirectionMean = null
+                lowDirectionMean = null
+                openDirectionMean = null
             }
 
             //negatives and positives
@@ -112,9 +131,23 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
             ? classifySize(gapSize, gapMean, 2, changeLevel) 
             : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
 
-            candle_position[x] = (isUp) 
-            ? classifySize(position, positionMean, 2, changeLevel) 
-            : -Math.abs(classifySize(position, positionMean, 2, changeLevel)) || 0;
+            candle_close_direction[x] = (isUp) 
+            ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
+
+            candle_high_direction[x] = (isUp) 
+            ? classifySize(highDirection, highDirectionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;  
+            
+            
+            candle_low_direction[x] = (isUp) 
+            ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
+
+            candle_open_direction[x] = (isUp) 
+            ? classifySize(openDirection, openDirectionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
+
             
             //positives only
             candle_top_size[x] = classifySize(topSize, topSizeMean, 0.5, sizeLevel)
@@ -125,7 +158,9 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
              //negatives and positives
              candle_body_size[x] = candleBodySize
              candle_gap_size[x] = gapSize
-             candle_position[x] = position
+             candle_close_direction[x] = closeDirection
+             candle_high_direction[x] = highDirection
+             candle_low_direction[x] = lowDirection
  
              //positives only
              candle_top_size[x] = topSize
@@ -141,6 +176,9 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         candle_top_size,
         candle_bottom_size,
         candle_shadow_size,
-        candle_position
+        candle_close_direction,
+        candle_high_direction,
+        candle_low_direction,
+        candle_open_direction
     }
 }

package/src/utilities/math-array.js

@@ -0,0 +1,64 @@
+//change between current and prev
+export const arrayChange = data => {
+
+    if(!Array.isArray(data))
+    {
+        throw Error('data param in arrayGt function must be array')
+    }
+
+    const output = Array(data.length).fill(0)
+
+    for (let x = 1; x < output.length; x++) {
+
+        if(data[x] === null || data[x - 1] === null)
+        {
+            output[x] === null
+        }
+        else
+        {
+            const curr = data[x]
+            const prev = data[x - 1]
+            output[x] = ((curr - prev) / prev) * 100
+        }
+    }
+
+    return output
+}
+
+//tells if array a is greater than array b
+
+export const arrayGt = (a, b) => {
+
+    if(!Array.isArray(a) || !Array.isArray(b))
+    {
+        throw Error('a and b params in arrayGt function must be arrays')
+    }
+    if(a.length !== b.length)
+    {
+        throw Error('array a and b must be the same length in arrayGt function')
+    }
+    if(a.length < 2)
+    {
+        throw Error('arrays in arrayGt function must have at least 2 numeric items')
+    }
+
+    const output = Array(a.length).fill(0.5)
+
+    for (let x = 1; x < output.length; x++) {
+
+        if(a[x] === null || b[x] === null)
+        {
+            output[x] = null
+        }
+        if(a[x] > b[x])
+        {
+            output[x] = 1
+        }
+        else if(a[x] < b[x])
+        {
+            output[x] = 0
+        }
+    }
+
+    return output
+}