ohlcv-indicators 3.5.4 → 3.5.42

package/src/studies/lag.js

@@ -1,77 +1,44 @@
-import { buildArray } from "../utilities/assignTypes.js";
-
-export const lag = (main, index) => {
-
-    const {instances, verticalOhlcv, len, arrayTypes, priceBased} = main
-
-    if(index === 0)
-    {
-        const {inputParams} = main
-
-        const params = []
-
-        for (const o of inputParams) {
-            if (o.key === 'lag') {
-                params.push(o.params)
-            }
-        }
-
-        for (const [colKeys, lookback] of params)
-        {
-            for (const colKey of colKeys)
-            {
-                if(priceBased.has(colKey))
-                {
-                    for (let step = 1; step <= lookback; step++) {
-                        priceBased.add(`${colKey}_lag_${step}`)
-                    }
-                }
-            }
-        }
-
-        instances.lag = {
-            lagParams: params
-        }
+import { buildArray } from "../utilities/assignTypes.js"
+
+export const lag = (main, index, colKeys, lookback) => {
+
+  
+  
+  const { verticalOhlcv, len, arrayTypes } = main
+
+  if(index === 0)
+  {
+    for (const colKey of colKeys) {
+      if (!arrayTypes.hasOwnProperty(colKey)) {
+          throw new Error(
+          `Lag processing invoked by "${colKey}" expected arrayTypes to have a "${colKey}" property, but it wasn’t found.`
+          )
+      }
+
+      for (let step = 1; step <= lookback; step++) {
+          const key = `${colKey}_lag_${step}`
+          verticalOhlcv[key] = buildArray(arrayTypes[colKey], len)
+          arrayTypes[key] = arrayTypes[colKey]
+      }   
     }
-    
-    const {lagParams} = instances.lag
-
-    for (const [colKeys, lookback] of lagParams) {
-    
-        for (const colKey of colKeys) {
-            const currentColumn = verticalOhlcv[colKey];
-    
-            // Initialize lagged arrays only on the first index
-            if (index === 0) {
-                for (let step = 1; step <= lookback; step++) {
-                    const key = `${colKey}_lag_${step}`;
-
-                    if(!arrayTypes.hasOwnProperty(colKey))
-                    {
-                        throw new Error(`Lag processing invoked by "${colKey}" expected arrayTypes to have a "${colKey}" property, but it wasn’t found.`)                          
-                    }
+  }
 
-                    verticalOhlcv[key] = buildArray(arrayTypes[colKey], len)
-                    arrayTypes[key] = arrayTypes[colKey]
-                }
-            }
+  for (const colKey of colKeys) {
+    const currentColumn = verticalOhlcv[colKey]
 
-            // Populate lagged values
-            for (let step = 1; step <= lookback; step++) {
-                const key = `${colKey}_lag_${step}`;
-                const laggedIndex = index - step;
+    // Populate the lagged values each tick:
+    for (let step = 1; step <= lookback; step++) {
+      const key = `${colKey}_lag_${step}`
+      const laggedIndex = index - step
+      const value =
+        laggedIndex < 0 || currentColumn[laggedIndex] === undefined
+          ? null
+          : currentColumn[laggedIndex]
 
-                const value = (laggedIndex <= 0 || typeof currentColumn[laggedIndex] === 'undefined') 
-                    ? null 
-                    : currentColumn[laggedIndex]
+      main.pushToMain({ index, key, value })
 
-                main.pushToMain({index, key, value})
-            }
-        }
     }
-    
-
-
+  }
 
-    return true;
-};
+  return true
+}

package/src/studies/mapCols.js

@@ -0,0 +1,47 @@
+export const mapCols = (main, index, newCols, callback, {lag}) => {
+
+    
+
+    const {verticalOhlcv, len, arrayTypes} = main
+
+    if(index === 0)
+    {
+
+        for(const key of newCols)
+        {
+            if(verticalOhlcv.hasOwnProperty(key)) {
+                throw new Error(`New property "${key}" already exist in "verticalOhlcv" and can not be modified using mapCols.`)
+            }
+
+            verticalOhlcv[key] = new Array(len).fill(0)
+            arrayTypes[key] = 'Array'
+        }
+
+        if(lag > 0)
+        {
+            main.lag(newCols, lag)
+        }
+    }
+
+    const cols = callback({index, main})
+
+    if(cols == null) return true
+
+    for(const [key, value] of Object.entries(cols))
+    {
+        main.pushToMain({ index, key, value })
+    }
+}
+
+export const defaultMapColsCallback = ({main, index}) => {
+    const {verticalOhlcv} = main
+
+    const currClose = verticalOhlcv.close[index]
+    const prevClose = verticalOhlcv.close[index-1]
+    
+    if(typeof prevClose === 'undefined') return null
+
+    return {
+        change: (currClose - prevClose) / prevClose
+    }
+} 

package/src/utilities/assignTypes.js

@@ -4,12 +4,28 @@ import { selectDateFormatter } from "./dateUtilities.js";
 const numberKeys = new Set(['open', 'high', 'low', 'close'])
 
 export const buildArray = (arrayType, len) => {
-  if(arrayType === 'Array') return new Array(len).fill(null)
-  if(arrayType === 'Float64Array') return new Float64Array(len).fill(NaN)
-  if(arrayType === 'Int32Array') return new Int32Array(len).fill(NaN)
+  const ctorMap = {
+    Array:        Array,
+    Float64Array: Float64Array,
+    Float32Array: Float32Array,
+    Int32Array:   Int32Array,
+    Uint8Array:   Uint8Array,
+    Int8Array:   Int8Array,
+    Int16Array:   Int16Array,
+  }
+
+  const Ctor = ctorMap[arrayType];
+  if (!Ctor || typeof Ctor.from !== 'function') {
+    throw new Error(`Unsupported array type: ${arrayType}`);
+  }
+  // Arrays get nulls, typed-arrays get NaNs
+  const fillValue = arrayType === 'Array' ? null : NaN;
+  // Ctor.from({ length }, mapFn) works for Array *and* all TypedArrays
+  return Ctor.from({ length: len }, () => fillValue);
 }
 
-export const assignTypes = firstRow => {
+export const assignTypes = main => {
+  const {firstRow, notNumberKeys} = main
   const inputTypes  = {}
   const arrayTypes  = {}
 
@@ -18,11 +34,13 @@ export const assignTypes = firstRow => {
     if (colName === 'date') {
       inputTypes[colName] = selectDateFormatter(cellValue, true)
       arrayTypes[colName] = 'Array'
+      notNumberKeys.add(colName)
     }
     else if(colName === 'volume')
     {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
+      notNumberKeys.add(colName)
     }
     else if(numberKeys.has(colName))
     {
@@ -32,6 +50,12 @@ export const assignTypes = firstRow => {
       const thisType = classifyNum(cellValue, false)
       inputTypes[colName] = thisType
       arrayTypes[colName] = (thisType === 'number') ? 'Float64Array' : 'Array'
+
+      if(!thisType.startsWith('number'))
+      {
+        notNumberKeys.add(colName)
+      }
+
     }
   }
 

package/src/utilities/numberUtilities.js

@@ -7,32 +7,6 @@ export const numberFormater = {
   numberDirtyString: n => Number(sanitizeDirtyNumberString(n))
 }
 
-export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
-    const output = {}
-
-    for(const [key, value] of Object.entries(row))
-    {
-
-        let newValue = value
-
-        if(priceBased.has(key))
-        {
-            newValue = newValue / precisionMultiplier
-        }
-
-        output[key] = newValue
-    }
-
-    return output
-} 
-
-// Parses a number from either a numeric or string input, applying a multiplier to fix precision issues
-export const parseNumber = (num, type, precisionMultiplier) => {
-  const addMultiplier = cNum => precisionMultiplier > 1 ? cNum * precisionMultiplier : cNum;
-
-  return addMultiplier(numberFormater[type](num))
-
-};
 
 export const classifyNum = (num, throwError = false) => {
   // 1) true numbers

package/src/utilities/order.js

@@ -0,0 +1,51 @@
+
+import { validateArray, validateString } from "./validators.js"
+
+export const getOrderFromArray = (arr, methodName) => {
+
+    validateArray(arr, 'arr', 'getOrderFromArray')
+    validateString(methodName, 'methodName', 'getOrderFromArray')
+
+    const level2Methods = ['regressor', 'classifier', 'pca']
+    const baseKeys = ['open', 'high', 'low', 'close', 'volume', 'date']
+
+    // 1. Level-2: does this method live in your level-2 list?
+    const isSecondary = level2Methods.includes(methodName);
+
+    // 2. Level-0: is every field one of the primitives *and* not level-2?
+    const isPrimary = arr.every(v => baseKeys.includes(v)) && !isSecondary;
+
+    if(isPrimary)
+    {
+        return 0
+    }
+
+    let order = 1
+    const level1Prefixes = ['_x_', 'zscore_', 'minmax_', 'lag_']
+
+    for(const k of level1Prefixes)
+    {
+        if(arr.some(v => v.includes(k)))
+        {
+            order++
+        }
+    }
+
+    if(!isSecondary)
+    {
+        return order
+    }
+
+    const level2Prefixes = ['prediction_', 'reg_', 'cla_', 'pca_']
+    order = 10
+
+    for(const k of level2Prefixes)
+    {
+        if(arr.some(v => v.includes(k)))
+        {
+            order++
+        }
+    }
+
+    return order
+}

package/src/utilities/precisionMultiplier.js

@@ -1,14 +1,13 @@
 export const calcPrecisionMultiplier = (main, firstRow) => {
-    const {precision, priceBased} = main
+    const {precision} = main
 
     if(precision === false) return 1
 
     let output = 1
-    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.has(k)).map(([_, v]) => v)
 
-
-    for(const value of priceBasedValues)
+    for(const [key, value] of Object.entries(firstRow))
     {
+        if(new Set(['open', 'high', 'low', 'close']).has(key) === false) continue
         const [, decimals = ''] = String(value).split('.')
         const decimalPrecision = Math.max(4, decimals.length)
         const multiplier = decimalPrecision > 1 ? Math.pow(10, decimalPrecision - 1) : 1

package/src/utilities/validators.js

@@ -132,4 +132,11 @@ export const validateArrayOfRanges = (range, paramName, callerName) => {
     }
 
     return true
+}
+
+export const validateString = (txt, paramName, callerName) => {
+
+  if(typeof txt !== 'string' || !txt.length) throw new Error(`Invalid "${paramName}" property in "${callerName}". Only strings are accepted.`)
+
+  return true
 }

package/src/utilities/verticalToHorizontal.js

@@ -2,7 +2,7 @@ import { dateOutputFormaters } from "./dateUtilities.js"
 
 export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, dateFormat}) => {
 
-  const {precisionMultiplier, priceBased, precision, verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols} = main
+  const {precisionMultiplier, precision, verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols, notNumberKeys} = main
 
   if (verticalOhlcvKeyNames.length === 0) return []
   
@@ -13,7 +13,7 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
 
    for(const [key, arr] of Object.entries(verticalOhlcv)){
     if(verticalOhlcvTempCols.has(key)) continue
-    const shouldApplyPrecision = priceBased.has(key) && precision
+    const shouldApplyPrecision = precision && !notNumberKeys.has(key)
 
     for (let i = maxStartIndex; i < len; i++)
     {

package/src/volatility/atr.js

@@ -7,7 +7,7 @@ export const atr = (main, index, size, {lag, percentage, upper, lower}) => {
 
   if (index === 0) {
 
-    const {instances, verticalOhlcv, arrayTypes, len, priceBased} = main
+    const {instances, verticalOhlcv, arrayTypes, len} = main
 
     instances[baseKeyName] = new FasterATR(size, FasterWSMA)
 
@@ -18,12 +18,7 @@ export const atr = (main, index, size, {lag, percentage, upper, lower}) => {
     if(lower !== null) keyNames.push(`${baseKeyName}_lower`)
 
     for(const k of keyNames)
-    {
-      if(!k.endsWith('_percentage'))
-      {
-        priceBased.add(k)
-      }
-      
+    { 
       verticalOhlcv[k] = new Float64Array(len).fill(NaN)
       arrayTypes[k] = 'Float64Array'
     }