ohlcv-indicators 1.8.4 → 1.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.8.4",
+  "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/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/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;
 };