ohlcv-indicators 1.8.3 → 1.8.5

package/index.js

@@ -192,10 +192,10 @@ export default class OHLCV_INDICATORS {
         return this
 
     }
-    bollingerBands(size, times)
+    bollingerBands(size, times, bollingerBandsStudies)
     {
 
-        const result = bollingerBands(this, size, times)
+        const result = bollingerBands(this, size, times, bollingerBandsStudies)
         Object.assign(this.indicators, result)
 
         this.priceBased.push('bollinger_bands_middle', 'bollinger_bands_upper', 'bollinger_bands_lower')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "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/bollingerBands.js

@@ -2,30 +2,36 @@
 import {FasterBollingerBands, FasterSMA} from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-export const bollingerBands = (main, size, times) => {
+export const bollingerBands = (main, size, times, bollingerBandsStudies) => {
 
   const {verticalOhlcv} = main
   const {close} = verticalOhlcv
 
-  const col = getBollingerBands(close, size, times)
+  const col = getBollingerBands(close, size, times, bollingerBandsStudies)
   return col
 }
 
-export const getBollingerBands = (data, size = 20, times = 2) => {
+export const getBollingerBands = (data, size = 20, times = 2, bollingerBandsStudies = false) => {
   
   const dataLength = data.length
   const bollinger_bands_upper =  Array(dataLength).fill(null)
   const bollinger_bands_middle =  Array(dataLength).fill(null)
   const bollinger_bands_lower =  Array(dataLength).fill(null)
-  const bollinger_bands_range =  Array(dataLength).fill(null)
-  const bollinger_bands_height =  Array(dataLength).fill(null)
 
 
-  const heightInstance = new FasterSMA(size)
-
+  let bollinger_bands_range
+  let bollinger_bands_height
+  let heightInstance
   let range = null
   let height = null
 
+  if(bollingerBandsStudies)
+  {
+    bollinger_bands_range =  Array(dataLength).fill(null)
+    bollinger_bands_height =  Array(dataLength).fill(null)
+    heightInstance = new FasterSMA(size)
+  }
+
   let getRange = (value, upper, lower) => ({
     range: ((value - lower) / (upper - lower)),
     height: upper-lower
@@ -52,6 +58,8 @@ export const getBollingerBands = (data, size = 20, times = 2) => {
     bollinger_bands_middle[x] = obj.middle;
     bollinger_bands_lower[x] = obj.lower;
 
+    if(bollingerBandsStudies === false) continue
+    
     if(hasNull)
     {
       bollinger_bands_range[x] = null
@@ -79,6 +87,13 @@ export const getBollingerBands = (data, size = 20, times = 2) => {
     bollinger_bands_height[x] = classifySize(height, heightMean, 1.5)
   }
 
-  return { bollinger_bands_upper, bollinger_bands_middle, bollinger_bands_lower, bollinger_bands_range, bollinger_bands_height }
+  let output = { bollinger_bands_upper, bollinger_bands_middle, bollinger_bands_lower }
+
+  if(bollingerBandsStudies)
+  {
+    output = {...output, bollinger_bands_range, bollinger_bands_height}
+  }
+
+  return output
 }
 

package/src/studies/candleStudies.js

@@ -1,16 +1,18 @@
 import {FasterSMA} from 'trading-signals'
 import { classifyChange, classifySize } from '../utilities/classification.js'
 
-export const candlesStudies = (main, period, classify) => {
+export const candlesStudies = (main, period, classify, classificationLevels) => {
 
     const {inputOhlcv, len} = main
 
-    const cols = getCandlesStudies(inputOhlcv, period, len, classify)
+    const cols = getCandlesStudies(inputOhlcv, period, len, classify, classificationLevels)
     return cols
 }
 
-const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true) => {
+const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classificationLevels = {}) => {
 
+    const {changeLevel = 7, sizeLevel = 5} = classificationLevels
+ 
     //close > open
     let candle_body_size = new Array(len).fill(null) //scaled candle direction close - open
     let candle_top_size = new Array(len).fill(null) //scaled top size (0, 0.5 and 1)
@@ -64,8 +66,8 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true) => {
         const shadowSize = curr.high - curr.low
 
         //sizes
-        const topSize = (candleBodySize > 0) ? high -  close : high - open
-        const bottomSize = (candleBodySize > 0) ? open - low : close - low
+        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
 
@@ -101,14 +103,14 @@ const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true) => {
             }
 
             //negatives and positives
-            candle_body_size[x] = classifyChange(candleBodySize, bodySizeMean, 0.5)
-            candle_gap_size[x] = classifyChange(gapSize, gapMean, 0.5)
-            candle_position[x] = classifyChange(position, positionMean, 0.5)
+            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)
 
             //positives only
-            candle_top_size[x] = classifySize(topSize, topSizeMean, 0.5)
-            candle_bottom_size[x] = classifySize(bottomSize, bottomSizeMean, 0.5)
-            candle_shadow_size[x] = classifySize(shadowSize, shadowSizeMean, 0.5)
+            candle_top_size[x] = classifySize(topSize, topSizeMean, 0.5, sizeLevel)
+            candle_bottom_size[x] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel)
+            candle_shadow_size[x] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel)
         }
         else{
              //negatives and positives

package/src/studies/findCrosses.js

@@ -202,7 +202,7 @@ export const crossPairs = (main, arr) => {
             }
 
         } else {
-            console.log(`Missing ohlcv properties for ${fast} or ${slow}`);
+            throw Error(`Missing ohlcv properties for ${fast} or ${slow}`);
         }
     }
 

package/src/utilities/classification.js

@@ -1,49 +1,44 @@
+export const classifySize = (value, mean, standardDeviation = 1.5, numLevels = 5) => {
+    if (value === null || mean === null || standardDeviation === null) return null
+    if (numLevels < 2) throw new Error("numLevels must be at least 2")
 
-export const classifySize = (value, mean, standardDeviation = 1.5) => {
+    // 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 + 1) / (numLevels - 1)
+        }
+    }
+
+    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");
   
-    const largeThreshold = mean + (2 * standardDeviation); // Large (2σ above mean)
-    const mediumThreshold = mean + (1 * standardDeviation); // Medium (1σ above mean)
-    const smallThreshold = mean - (1 * standardDeviation); // Small (1σ below mean)
-    const verySmallThreshold = mean - (1.5 * standardDeviation); // Very small (1.5σ below mean)
+    // Calculate the range for each level
+    const step = (4 * standardDeviation) / (numLevels - 1);
+    const thresholds = [];
   
-    if (value > largeThreshold) {
-        return 1;        // Large
-    } else if (value > mediumThreshold) {
-        return 0.75;    // Medium
-    } else if (value > smallThreshold) {
-        return 0.5;    // Small
-    } else if (value > verySmallThreshold) {
-        return 0.25;    // Very small
-    } else {
-        return 0;    // Insignificant
+    for (let i = 0; i < numLevels - 1; i++) {
+        thresholds.push(mean - (2 * standardDeviation) + (i * step));
     }
-  };
   
-
-  export const classifyChange = (value, mean, standardDeviation = 0.5) => {
-    if (value === null || mean === null || standardDeviation === null) return null;
-
-    const largePositiveThreshold = mean + (2 * standardDeviation); // Large positive
-    const mediumPositiveThreshold = mean + (1.5 * standardDeviation); // Medium positive (1.5σ)
-    const smallPositiveThreshold = mean + (0.5 * standardDeviation); // Small positive (0.5σ)
-    const smallNegativeThreshold = mean - (0.5 * standardDeviation); // Small negative (-0.5σ)
-    const mediumNegativeThreshold = mean - (1.5 * standardDeviation); // Medium negative (-1.5σ)
-    const largeNegativeThreshold = mean - (2 * standardDeviation); // Large negative
-
-    if (value >= largePositiveThreshold) {
-        return 1;    // Large positive
-    } else if (value >= mediumPositiveThreshold) {
-        return 0.5; // Medium positive
-    } else if (value >= smallPositiveThreshold) {
-        return 0.25; // Small positive
-    } else if (value <= largeNegativeThreshold) {
-        return -1;   // Large negative
-    } else if (value <= mediumNegativeThreshold) {
-        return -0.5; // Medium negative
-    } else if (value <= smallNegativeThreshold) {
-        return -0.25; // Small negative
-    } else {
-        return 0; // No significant change
+    // 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;
 };