ohlcv-indicators 3.4.9 → 3.5.0

package/dist/ohlcv-indicators.min.js

@@ -2905,44 +2905,30 @@ var OHLCV_INDICATORS;
                 });
             },
             atr: function(t, e, r, n) {
-                var o = n.lag, i = n.tp, a = n.sl, u = t.verticalOhlcv, l = t.instances, c = "atr_".concat(r);
+                var o = n.lag, i = n.type, a = t.verticalOhlcv, u = t.instances, l = "percentage" === i ? "atr_".concat(r, "_percentage") : "atr_".concat(r);
                 if (0 === e) {
-                    var s = t.instances, f = t.verticalOhlcv, y = t.arrayTypes, p = t.len, h = t.priceBased;
-                    s[c] = new Yt(r, jt);
-                    var v = [ c ];
-                    null !== i && v.push("".concat(c, "_tp")), null !== a && v.push("".concat(c, "_sl"));
-                    for (var m = 0, d = v; m < d.length; m++) {
-                        var b = d[m];
-                        h.add(b), f[b] = new Float64Array(p).fill(NaN), y[b] = "Float64Array";
-                    }
-                    o > 0 && t.lag(v, o);
+                    var c = t.instances, s = t.verticalOhlcv, f = t.arrayTypes, y = t.len, p = t.priceBased;
+                    c[l] = new Yt(r, jt), "price" === i && p.add(l), s[l] = new Float64Array(y).fill(NaN), 
+                    f[l] = "Float64Array", o > 0 && t.lag([ l ], o);
                 }
                 // Retrieve the current price value.
-                                var g = {
-                    high: u.high[e],
-                    low: u.low[e],
-                    close: u.close[e]
-                }, w = l[c];
+                                var h = {
+                    high: a.high[e],
+                    low: a.low[e],
+                    close: a.close[e]
+                }, v = u[l];
                 // Update the moving average instance.
-                w.update(g);
-                var O = NaN;
+                v.update(h);
+                var m = NaN;
                 try {
-                    O = w.getResult();
+                    m = v.getResult();
                 } catch (t) {}
-                return null !== i && t.pushToMain({
-                    index: e,
-                    key: "".concat(c, "_tp"),
-                    value: Number.isNaN(O) ? NaN : g.close + O * i
-                }), null !== a && t.pushToMain({
-                    index: e,
-                    key: "".concat(c, "_sl"),
-                    value: Number.isNaN(O) ? NaN : g.close - O * a
-                }), 
+                return "percentage" === i && (m = Number.isNaN(m) ? NaN : m / h.close), 
                 // Always push the MA value (even if NaN).
                 t.pushToMain({
                     index: e,
-                    key: c,
-                    value: O
+                    key: l,
+                    value: m
                 }), !0;
             },
             ema: Ce,
@@ -3946,25 +3932,16 @@ var OHLCV_INDICATORS;
                         max: this.len,
                         allowDecimals: !1
                     }, "size", r), s(e, "options", r);
-                    var n = e.lag, o = void 0 === n ? 0 : n, i = e.tp, a = void 0 === i ? null : i, u = e.sl, c = void 0 === u ? null : u;
+                    var n = e.lag, o = void 0 === n ? 0 : n, i = e.type, a = void 0 === i ? "price" : i;
                     return p(o, {
                         min: 0,
                         max: this.len,
                         allowDecimals: !1
-                    }, "options.lag", r), null !== a && p(a, {
-                        min: .01,
-                        max: 100,
-                        allowDecimals: !0
-                    }, "options.tp", r), null !== c && p(c, {
-                        min: .01,
-                        max: 100,
-                        allowDecimals: !0
-                    }, "options.tp", r), this.inputParams.push({
+                    }, "options.lag", r), f([ "price", "percentage" ], a, "options.type", r), this.inputParams.push({
                         key: r,
                         params: [ t, {
                             lag: o,
-                            tp: a,
-                            sl: c
+                            type: a
                         } ]
                     }), this;
                 }

package/index.js

@@ -268,14 +268,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {lag = 0, tp = null, sl = null} = options
+        const {lag = 0, type = 'price'} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateArrayOptions(['price', 'percentage'], type, 'options.type', methodName)
 
-        if(tp !== null) validateNumber(tp, {min: 0.01, max: 100, allowDecimals: true}, 'options.tp', methodName)
-        if(sl !== null) validateNumber(sl, {min: 0.01, max: 100, allowDecimals: true}, 'options.tp', methodName)
-
-        this.inputParams.push({key: methodName, params: [size, {lag, tp, sl}]})
+        this.inputParams.push({key: methodName, params: [size, {lag, type}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.4.9",
+  "version": "3.5.0",
   "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/volatility/atr.js

@@ -1,39 +1,27 @@
 
 import {FasterATR, FasterWSMA} from 'trading-signals';
 
-export const atr = (main, index, size, {lag, tp, sl}) => {
+export const atr = (main, index, size, {lag, type}) => {
   const { verticalOhlcv, instances } = main
-  const keyName = `atr_${size}`
+  const keyName = (type === 'percentage') ? `atr_${size}_percentage`  : `atr_${size}` 
 
   if (index === 0) {
 
     const {instances, verticalOhlcv, arrayTypes, len, priceBased} = main
 
     instances[keyName] = new FasterATR(size, FasterWSMA)
-    
-    const keyNames = [keyName]
-
-    if(tp !== null)
-    {
-      keyNames.push(`${keyName}_tp`)
-    }
-
-    if(sl !== null)
-    {
-       keyNames.push(`${keyName}_sl`)
-    }
 
-    for(const k of keyNames)
+    if(type === 'price')
     {
-      priceBased.add(k)
-      verticalOhlcv[k] = new Float64Array(len).fill(NaN)
-      arrayTypes[k] = 'Float64Array'
+      priceBased.add(keyName)
     }
     
-
+    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
+    arrayTypes[keyName] = 'Float64Array'
+    
     if(lag > 0)
     {
-      main.lag(keyNames, lag)
+      main.lag([keyName], lag)
     }
   }
 
@@ -54,14 +42,9 @@ export const atr = (main, index, size, {lag, tp, sl}) => {
 
   }
 
-  if(tp !== null)
-  {
-    main.pushToMain({ index, key: `${keyName}_tp`, value: (!Number.isNaN(currAtr)) ? curr.close + (currAtr*tp) : NaN });
-  }
-
-  if(sl !== null)
+  if(type === 'percentage')
   {
-    main.pushToMain({ index, key: `${keyName}_sl`, value: (!Number.isNaN(currAtr)) ? curr.close - (currAtr*sl) : NaN });
+    currAtr = (Number.isNaN(currAtr)) ? NaN : (currAtr / curr.close)
   }
 
   // Always push the MA value (even if NaN).