ohlcv-indicators 1.8.6 → 1.8.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "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

@@ -1,5 +1,5 @@
 import {FasterSMA} from 'trading-signals'
-import { classifyChange, classifySize } from '../utilities/classification.js'
+import { classifySize } from '../utilities/classification.js'
 
 export const candlesStudies = (main, period, classify, classificationLevels) => {
 
@@ -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_position =  new Array(len).fill(null) //scaled shadow size curr.close - prev.close
+    let candle_high_position = new Array(len).fill(null) //scaled shadow size curr.high - prev.high
+    let candle_low_position = new Array(len).fill(null) //scaled shadow size curr.low - prev.low
+    let candle_open_position = 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 closePositionInstance
+    let highPositionInstance
+    let lowPositionInstance
+    let openPositionInstance
 
     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)
+        closePositionInstance = new FasterSMA(period)
+        highPositionInstance = new FasterSMA(period)
+        lowPositionInstance = new FasterSMA(period)
+        openPositionInstance = 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,17 +64,24 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
         let topSizeMean = null
         let bodySizeMean = null
         let shadowSizeMean = null
-        let positionMean = null
+        let closePositionMean = null
+        let highPositionMean = null
+        let lowPositionMean = null
+        let openPositionMean = null
 
         //directions
-        const candleBodySize = close - open // 1 for bullish and 0 for bearish
-        const shadowSize = curr.high - curr.low
+        const isUp = close > open
+        const candleBodySize = Math.abs(close - open)
+        const shadowSize = Math.abs(curr.high - curr.low)
 
         //sizes
         const topSize = high - Math.max(open, close)
         const bottomSize = Math.min(open, close) - low
-        const gapSize = prev.close - curr.open
-        const position = curr.close - prev.close
+        const gapSize = Math.abs(prev.close - curr.open)
+        const closePosition = Math.abs(curr.close - prev.close)
+        const highPosition = Math.abs(curr.high - prev.high)
+        const lowPosition = Math.abs(curr.low - prev.low)
+        const openPosition = Math.abs(curr.open - prev.open)
 
         if(classify)
         {
@@ -80,8 +92,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
 
             gapInstance.update(gapSize)
             bodySizeInstance.update(candleBodySize)
-            positionInstance.update(position)
-            
+            closePositionInstance.update(closePosition)
+            highPositionInstance.update(highPosition)
+            lowPositionInstance.update(lowPosition)
+            openPositionInstance.update(openPosition)
             
             try
             {
@@ -90,7 +104,10 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
                 gapMean = gapInstance.getResult()
                 bodySizeMean = bodySizeInstance.getResult()
                 shadowSizeMean = shadowSizeInstance.getResult()
-                positionMean = positionInstance.getResult()
+                closePositionMean = closePositionInstance.getResult()
+                highPositionMean = highPositionInstance.getResult()
+                lowPositionMean = lowPositionInstance.getResult()
+                openPositionMean = openPositionInstance.getResult()
             }
             catch(err)
             {
@@ -99,14 +116,39 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classi
                 topSizeMean = null
                 bottomSizeMean = null
                 shadowSizeMean = null
-                positionMean = null
+                closePositionMean = null
+                highPositionMean = null
+                lowPositionMean = null
+                openPositionMean = null
             }
 
             //negatives and positives
-            candle_body_size[x] = classifyChange(candleBodySize, bodySizeMean, 0.5, changeLevel)
-            candle_gap_size[x] = classifyChange(gapSize, gapMean, 0.5, changeLevel)
-            candle_position[x] = classifyChange(position, positionMean, 0.5, changeLevel)
+            candle_body_size[x] = (isUp) 
+            ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel) 
+            : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
+
+            candle_gap_size[x] = (isUp) 
+            ? classifySize(gapSize, gapMean, 2, changeLevel) 
+            : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
+
+            candle_close_position[x] = (isUp) 
+            ? classifySize(closePosition, closePositionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(closePosition, closePositionMean, 2, changeLevel)) || 0;
 
+            candle_high_position[x] = (isUp) 
+            ? classifySize(highPosition, highPositionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(highPosition, highPositionMean, 2, changeLevel)) || 0;  
+            
+            
+            candle_low_position[x] = (isUp) 
+            ? classifySize(lowPosition, lowPositionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(lowPosition, lowPositionMean, 2, changeLevel)) || 0;
+
+            candle_open_position[x] = (isUp) 
+            ? classifySize(openPosition, openPositionMean, 2, changeLevel) 
+            : -Math.abs(classifySize(openPosition, openPositionMean, 2, changeLevel)) || 0;
+
+            
             //positives only
             candle_top_size[x] = classifySize(topSize, topSizeMean, 0.5, sizeLevel)
             candle_bottom_size[x] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel)
@@ -116,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_position[x] = closePosition
+             candle_high_position[x] = highPosition
+             candle_low_position[x] = lowPosition
  
              //positives only
              candle_top_size[x] = topSize
@@ -132,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_position,
+        candle_high_position,
+        candle_low_position,
+        candle_open_position
     }
 }

package/src/utilities/classification.js

@@ -18,32 +18,4 @@ export const classifySize = (value, mean, standardDeviation = 1.5, numLevels = 5
     }
 
     return 0
-}
-
-
-export const classifyChange = (value, mean, standardDeviation = 0.5, numLevels = 7) => {
-    if (value === null || mean === null || standardDeviation === null) return null;
-    if (numLevels < 2) throw new Error("numLevels must be at least 2");
-  
-    // Handle numLevels == 2 explicitly
-    if (numLevels === 2) {
-        return value >= mean ? 1 : -1;
-    }
-  
-    // Calculate the range for each level
-    const step = (4 * standardDeviation) / (numLevels - 1);
-    const thresholds = [];
-  
-    for (let i = 0; i < numLevels - 1; i++) {
-        thresholds.push(mean - (2 * standardDeviation) + (i * step));
-    }
-  
-    // Classify the value based on calculated thresholds
-    for (let i = thresholds.length - 1; i >= 0; i--) {
-        if (value > thresholds[i]) {
-            return (i - Math.floor((numLevels - 1) / 2)) / Math.floor((numLevels - 1) / 2);
-        }
-    }
-  
-    return -1;
-};
+}

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
+}