ohlcv-indicators 3.5.79 → 3.5.80

package/src/moving-averages/movingAverages.js

@@ -2,17 +2,18 @@
 import {FasterEMA, FasterSMA} from '../core-indicators/index.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
+import { mathLog } from '../utilities/math.js';
 
 const indicatorClasses = {
   ema: FasterEMA, 
   sma: FasterSMA
 }
 
-export const movingAverages = (main, index, methodName, size, { target, lag }) => {
+export const movingAverages = (main, index, methodName, size, { target, lag, retLogs = false }) => {
 
   const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
-  const keyName = `${methodName}_${size}${suffix}`
+  const keyName = `${retLogs ? 'ret_log_' : ''}${methodName}_${size}${suffix}`
 
   if (index === 0) {
     validateInputValues({ [target]: true }, verticalOhlcv, index, methodName)
@@ -26,7 +27,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
     // Create the main moving average instance.
     instances[keyName] = new indicatorClasses[methodName](size)
 
-    initializeColumns(main, [{ key: keyName, priceBased: priceBased.has(target) }], { lag })
+    initializeColumns(main, [{ key: keyName, priceBased: !retLogs && priceBased.has(target) }], { lag })
   }
 
   // Retrieve the current price value
@@ -38,6 +39,15 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
   const currMa = instance.isStable ? instance.getResult() : NaN
 
-  // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currMa })
+  let output = currMa
+  if (retLogs) {
+    const ratio = value / currMa
+    // Log-relative distance is defined only for finite, positive ratios and operands.
+    output = value > 0 && currMa > 0 && ratio > 0 && Number.isFinite(ratio)
+      ? mathLog(ratio, 1)
+      : NaN
+  }
+
+  // Always push the selected value (even if NaN).
+  main.pushToMain({ index, key: keyName, value: output })
 }

package/src/moving-averages/relativeVolume.js

@@ -1,12 +1,12 @@
 import { FasterSMA } from '../core-indicators/index.js';
-import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { mathLog } from '../utilities/math.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 
-export const relativeVolume = (main, index, size, {lag}) => {
+export const relativeVolume = (main, index, size, {lag, retLogs = false}) => {
 
-  const key = `relative_volume_${size}`;
+  const key = `${retLogs ? 'ret_log_' : ''}relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;
   
 
@@ -42,9 +42,13 @@ export const relativeVolume = (main, index, size, {lag}) => {
     return
   }
 
-  let currRelativeVolume =  volume / prevSma;
+  const ratio = volume / prevSma;
+  const currRelativeVolume = retLogs
+    ? volume > 0 && prevSma > 0 && ratio > 0 && Number.isFinite(ratio)
+      ? mathLog(ratio, 1)
+      : NaN
+    : ratio;
 
   main.pushToMain({ index, key, value: currRelativeVolume });
-  instances[key].prevRelativeVolumeSma = smaValue;
 
 };

package/src/oscillators/mfi.js

@@ -0,0 +1,56 @@
+import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
+export const mfi = (main, index, size, { lag, retLogs }) => {
+    const { verticalOhlcv, instances } = main;
+    const key = `${retLogs ? 'ret_log_' : ''}mfi_${size}`;
+
+    if (index === 0) {
+        validateInputValues({ high: true, low: true, close: true, volume: true }, verticalOhlcv, index, 'mfi');
+        // Raw and logged variants own separate state, even at the same period.
+        initializeColumns(main, [{ key }], { lag });
+        instances[key] = {
+            flows: new Float64Array(size),
+            next: 0,
+            count: 0,
+            previousTypical: NaN
+        };
+    }
+
+    const state = instances[key];
+    const typical = (verticalOhlcv.high[index] + verticalOhlcv.low[index] + verticalOhlcv.close[index]) / 3;
+    const change = typical - state.previousTypical;
+    state.previousTypical = typical;
+
+    // The first candle seeds the comparison; a size-period MFI needs size + 1 rows.
+    if (index === 0) return;
+
+    const flow = typical * verticalOhlcv.volume[index];
+    // A tie is neutral, but an invalid comparison must not silently become zero.
+    // Zero-volume candles contribute zero and still advance the candle window.
+    state.flows[state.next] = Number.isFinite(change) && Number.isFinite(flow) && flow >= 0
+        ? Math.sign(change) * flow : NaN;
+    state.next = (state.next + 1) % size;
+    if (state.count < size) state.count++;
+    if (state.count < size) return;
+
+    // Sum oldest to newest: bounded storage, no accumulated subtraction drift,
+    // and invalid values recover naturally after leaving the window.
+    let positive = 0;
+    let negative = 0;
+    let slot = state.next;
+    for (let step = 0; step < size; step++) {
+        const value = state.flows[slot];
+        if (Number.isNaN(value)) return;
+        if (value > 0) positive += value;
+        else if (value < 0) negative -= value;
+        if (++slot === size) slot = 0;
+    }
+
+    if (!Number.isFinite(positive) || !Number.isFinite(negative)) return;
+    // No directional money flow gives an undefined ratio, not a neutral signal.
+    const value = positive === 0 && negative === 0
+        ? NaN : 100 - 100 / (1 + positive / negative);
+    main.pushToMain({ index, key, value: Number.isNaN(value) ? NaN : retLogs ? mathLog(value, 50) : value });
+};

package/src/oscillators/volumeOscillator.js

@@ -7,7 +7,7 @@ import { initializeColumns } from '../core-functions/initializeColumns.js';
 export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
 
     const {verticalOhlcv, instances} = main
-    const key = `volume_oscillator_${fast}_${slow}`
+    const key = retLogs ? `ret_log_volume_oscillator_${fast}_${slow}` : `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
         validateInputValues({ volume: true }, verticalOhlcv, index, 'volumeOscillator');
@@ -19,10 +19,7 @@ export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
             }
         })
 
-        initializeColumns(main, [
-            { key },
-            { key: `ret_log_${key}`, enabled: retLogs }
-        ], { lag });
+        initializeColumns(main, [{ key }], { lag });
     }
 
     const { fastEMA, slowEMA } = instances[key];
@@ -46,12 +43,9 @@ export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
         return;
     }
 
-    volumeOscValue = 100 * (fastValue - slowValue) / slowValue
-
-    if(retLogs) {
-        volumeOscRetLog = mathLog(fastValue, slowValue)
-        main.pushToMain({index, key: `ret_log_${key}`, value:  volumeOscRetLog})
-    }
+    volumeOscValue = retLogs
+        ?  mathLog(fastValue, slowValue)
+        : 100 * (fastValue - slowValue) / slowValue
 
     main.pushToMain({index, key, value:  volumeOscValue})
 };

package/src/studies/candleFeatures.js

@@ -56,14 +56,34 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const upperWickTop = Math.max(currOpen, currClose)
     const lowerWickTop = Math.min(currOpen, currClose)
 
+    const change = getRet(currClose, prevClose)
+    const midPriceChange = getRet(currMidPrice, prevMidPrice)
+    const upperWick = getRet(currHigh, upperWickTop)
+    const lowerWick = getRet(lowerWickTop, currLow)
+    const gap = getRet(currOpen, prevClose)
+    const body = getRet(currClose, currOpen)
+    const range = getRet(currHigh, currLow)
+
+    if (colKeys.length === 0) {
+        main.pushToMain({ index, key: `${prefix}change`, value: change })
+        main.pushToMain({ index, key: `${prefix}mid_price_change`, value: midPriceChange })
+        main.pushToMain({ index, key: `${prefix}upper_wick`, value: upperWick })
+        main.pushToMain({ index, key: `${prefix}lower_wick`, value: lowerWick })
+        main.pushToMain({ index, key: `${prefix}gap`, value: gap })
+        main.pushToMain({ index, key: `${prefix}body`, value: body })
+        main.pushToMain({ index, key: `${prefix}range`, value: range })
+        return
+    }
+
+    // Keep optional-target overwrite/order semantics and all-or-nothing validation.
     const row = {
-        [`${prefix}change`]: getRet(currClose, prevClose),
-        [`${prefix}mid_price_change`]: getRet(currMidPrice, prevMidPrice),
-        [`${prefix}upper_wick`]: getRet(currHigh, upperWickTop),
-        [`${prefix}lower_wick`]: getRet(lowerWickTop, currLow),
-        [`${prefix}gap`]: getRet(currOpen, prevClose),
-        [`${prefix}body`]: getRet(currClose, currOpen),
-        [`${prefix}range`]: getRet(currHigh, currLow)
+        [`${prefix}change`]: change,
+        [`${prefix}mid_price_change`]: midPriceChange,
+        [`${prefix}upper_wick`]: upperWick,
+        [`${prefix}lower_wick`]: lowerWick,
+        [`${prefix}gap`]: gap,
+        [`${prefix}body`]: body,
+        [`${prefix}range`]: range
     }
 
     let hasInvalidTarget = false
@@ -86,4 +106,4 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
          main.pushToMain({index, key, value})
     }
 
-}
+}

package/src/studies/dateTime.js

@@ -1,6 +1,8 @@
 import {oneHotEncode} from '../machine-learning/ml-utilities.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
 
+const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
 export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     
@@ -40,43 +42,44 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     const currDate = verticalOhlcv.date[index]
 
-    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes, formatter)
-
-    for(const [key, value] of Object.entries(dateInfo))
-    {
-        main.pushToMain({index, key, value})
+    let yearPart, monthPart, hourPart, minutePart, weekdayPart, dayPart
+    for (const part of formatter.formatToParts(currDate)) {
+        switch (part.type) {
+            case 'year': yearPart = part.value; break
+            case 'month': monthPart = part.value; break
+            case 'hour': hourPart = part.value; break
+            case 'minute': minutePart = part.value; break
+            case 'weekday': weekdayPart = part.value; break
+            case 'day': dayPart = part.value; break
+        }
+    }
+    const year = Number(yearPart)
+    const month = Number(monthPart) - 1
+    const hour = Number(hourPart)
+    const minute = Number(minutePart)
+    const dayOfWeek = weekdays.indexOf(weekdayPart)
+    const dayOfMonth = Number(dayPart) - 1
+
+    if (!oneHot) {
+        main.pushToMain({ index, key: 'year', value: year })
+        main.pushToMain({ index, key: 'month', value: month + 1 })
+        main.pushToMain({ index, key: 'hour', value: hour })
+        main.pushToMain({ index, key: 'minute', value: minute })
+        main.pushToMain({ index, key: 'day_of_the_week', value: ((dayOfWeek + 6) % 7) + 1 })
+        main.pushToMain({ index, key: 'day_of_the_month', value: dayOfMonth + 1 })
+        return
     }
-}
-
-
-
-const getDateInfo = (date, oneHot, colKeySizes, formatter) => {
-
-
-  const parts = Object.fromEntries(formatter.formatToParts(date).map(({ type, value }) => [type, value]));
-  const year = Number(parts.year);
-  const month = Number(parts.month) - 1;
-  const hour = Number(parts.hour);
-  const minute = Number(parts.minute);
-  const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(parts.weekday);
-  const dayOfMonth = Number(parts.day) - 1;
-
-  if (!oneHot) {
-    return {
-      year: year,
-      month: month + 1,  //iso month
-      hour: hour,
-      minute: minute,
-      day_of_the_week: ((dayOfWeek + 6) % 7) + 1, //iso date of the week
-      day_of_the_month: dayOfMonth + 1,  //iso date of the month
-    };
-  }
 
-  return {
-    one_hot_month: oneHotEncode(month, colKeySizes.one_hot_month),
-    one_hot_hour: oneHotEncode(hour, colKeySizes.one_hot_hour),
-    one_hot_minute: oneHotEncode(minute, colKeySizes.one_hot_minute),
-    one_hot_day_of_the_week: oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week),
-    one_hot_day_of_the_month: oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month),
-  };
-};
+    // Build a fresh vector for every field and row before writing.
+    const oneHotMonth = oneHotEncode(month, colKeySizes.one_hot_month)
+    const oneHotHour = oneHotEncode(hour, colKeySizes.one_hot_hour)
+    const oneHotMinute = oneHotEncode(minute, colKeySizes.one_hot_minute)
+    const oneHotWeekday = oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week)
+    const oneHotDay = oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month)
+
+    main.pushToMain({ index, key: 'one_hot_month', value: oneHotMonth })
+    main.pushToMain({ index, key: 'one_hot_hour', value: oneHotHour })
+    main.pushToMain({ index, key: 'one_hot_minute', value: oneHotMinute })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_week', value: oneHotWeekday })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_month', value: oneHotDay })
+}

package/src/studies/findCrosses.js

@@ -24,11 +24,7 @@ class CrossInstance {
             prevSlow: NaN,
             prevHigh: NaN,
             prevLow: NaN,
-            areHighAndLowUndefined: false,
-            crossIndexes: {
-                up: [],
-                down: []
-            }
+            areHighAndLowUndefined: false
         })        
 
     }
@@ -115,9 +111,6 @@ class CrossInstance {
         }
 
 
-        if(this.interval === 1) this.crossIndexes.up.push(index)
-        if(this.interval === -1) this.crossIndexes.down.push(index)
-
         //save prev state
         Object.assign(this, {
             prevState: currState,
@@ -238,4 +231,4 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
   }
 
-}
+}

package/src/studies/lag.js

@@ -10,27 +10,27 @@ export const lag = (main, index, colKeys, lookback) => {
   {
     const lagColumns = new Map()
 
-    for (const targetKey of colKeys) {
-      if (!verticalOhlcv.hasOwnProperty(targetKey)) {
+    for (const target of colKeys) {
+      if (!verticalOhlcv.hasOwnProperty(target)) {
         throw new Error(
-        `Lag processing invoked by col "${targetKey}" was not found in "verticalOhlcv".`
+        `Lag processing invoked by col "${target}" was not found in "verticalOhlcv".`
         )
       }
 
-      const addToPriceBased = priceBased.has(targetKey)
-      const type = Array.isArray(verticalOhlcv[targetKey]) ? 'Array' : 'Float64Array'
+      const addToPriceBased = priceBased.has(target)
+      const type = Array.isArray(verticalOhlcv[target]) ? 'Array' : 'Float64Array'
       const columns = []
       const keyNames = []
 
       for (let step = 1; step <= lookback; step++) {
-        const key = `${targetKey}_lag_${step}`
+        const key = `${target}_lag_${step}`
 
         columns.push({ key, type, priceBased: addToPriceBased, includeInLag: false })
         keyNames.push(key)
       }   
 
       initializeColumns(main, columns)
-      lagColumns.set(targetKey, keyNames)
+      lagColumns.set(target, keyNames)
     }
 
     // colKeys belongs to the runtime queue; keep cached names out of exported params.
@@ -40,15 +40,14 @@ export const lag = (main, index, colKeys, lookback) => {
 
   const lagColumns = instances[lagColumnsKey]?.get(colKeys)
 
-  for (const targetKey of colKeys) {
-    const keyNames = lagColumns?.get(targetKey)
-    const currentColumn = verticalOhlcv[targetKey]
+  for (const target of colKeys) {
+    const keyNames = lagColumns?.get(target)
+    const currentColumn = verticalOhlcv[target]
     const missingValue = Array.isArray(currentColumn) ? null : NaN
 
     // Populate the lagged values each tick:
     for (let step = 1; step <= lookback; step++) {
-      // Runtime callbacks may change the target list or lookback after initialization.
-      const key = keyNames?.[step - 1] ?? `${targetKey}_lag_${step}`
+      const key = keyNames?.[step - 1] ?? `${target}_lag_${step}`
       const laggedIndex = index - step
       const value =
         laggedIndex < 0 || currentColumn[laggedIndex] == null

package/src/utilities/config.js

@@ -1,15 +1,11 @@
-import { defaultMapColsCallback } from '../studies/mapCols.js';
-
 export const CONFIG_VERSION = 1;
-const mapCallbacks = new Map([['default', defaultMapColsCallback]]);
 
 // Copy configuration without JSON's silent conversion of functions/NaN to null.
-export const copyConfig = (value, allowFunctions = false, ancestors = new Set()) => {
+export const copyConfig = (value, ancestors = new Set()) => {
   if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
   if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'function' && allowFunctions) return value;
   if (typeof value !== 'object' || value === null) {
-    throw new TypeError('Configuration values must be JSON-safe: no undefined, non-finite numbers, or unregistered functions.');
+    throw new TypeError('Configuration values must be JSON-safe: no undefined, non-finite numbers, or functions.');
   }
   if (ancestors.has(value)) throw new TypeError('Configuration must not contain circular references.');
   const prototype = Object.getPrototypeOf(value);
@@ -20,8 +16,8 @@ export const copyConfig = (value, allowFunctions = false, ancestors = new Set())
 
   ancestors.add(value);
   const result = Array.isArray(value)
-    ? Array.from(value, item => copyConfig(item, allowFunctions, ancestors))
-    : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyConfig(item, allowFunctions, ancestors)]));
+    ? Array.from(value, item => copyConfig(item, ancestors))
+    : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyConfig(item, ancestors)]));
   ancestors.delete(value);
   return result;
 };
@@ -33,32 +29,3 @@ export const freezeConfig = value => {
   }
   return value;
 };
-
-export const registerMapCallback = (name, callback) => {
-  if (typeof name !== 'string' || !name || typeof callback !== 'function') {
-    throw new TypeError('registerMapCallback requires a nonempty name and a function.');
-  }
-  if (mapCallbacks.has(name) && mapCallbacks.get(name) !== callback) {
-    throw new Error(`mapCols callback "${name}" is already registered. Use a new versioned name.`);
-  }
-  mapCallbacks.set(name, callback);
-};
-
-export const resolveMapCallback = callback => {
-  if (typeof callback === 'function') return callback;
-  if (typeof callback === 'string' && mapCallbacks.has(callback)) return mapCallbacks.get(callback);
-  throw new Error(`Unknown mapCols callback "${callback}". Register it before loading the configuration.`);
-};
-
-export const exportInputParams = inputParams => {
-  const result = copyConfig(inputParams, true);
-  for (const job of result) {
-    if (job.key !== 'mapCols' || typeof job.params[1] !== 'function') continue;
-    const entry = [...mapCallbacks].find(([, callback]) => callback === job.params[1]);
-    if (!entry) {
-      throw new Error('Cannot export an unregistered mapCols callback. Register it with OHLCV_INDICATORS.registerMapCallback(name, callback).');
-    }
-    job.params[1] = entry[0];
-  }
-  return copyConfig(result);
-};

package/src/utilities/numberUtilities.js

@@ -5,13 +5,13 @@ export const isPositiveInteger = n => Number.isInteger(n) && n >= 0;
 export const inputNumberFormatter = {
   number: n => n,
   numberCleanString: n => Number(n),
-  precisionNumberCleanString: (strNum, multiplier) => addPrecisionAsNumber(strNum, multiplier)
+  precisionNumberCleanString: (strNum, multiplier, cachedDecimals) => addPrecisionAsNumber(strNum, multiplier, cachedDecimals)
 }
 
 export const outputNumberFormatter = {
   number: n => n,
   numberCleanString: n => n,
-  precisionNumberCleanString: (strNum, multiplier) => revertPrecisionAsNumber(strNum, multiplier)
+  precisionNumberCleanString: (strNum, multiplier, cachedDecimals) => revertPrecisionAsNumber(strNum, multiplier, cachedDecimals)
 }
 
 export const classifyNum = (num, throwError = false, precision = false) => {
@@ -34,4 +34,4 @@ export const classifyNum = (num, throwError = false, precision = false) => {
 
   if(throwError) throw new TypeError('Invalid input: expected a number or numeric string')
   return typeof num
-}
+}

package/src/utilities/precisionMultiplier.js

@@ -51,8 +51,14 @@ export const calcPrecisionMultiplier = main => {
 }
 
 
+// Keep the existing decimal-width rule, including scientific-notation multipliers.
+export const getPrecisionDecimals = multiplier => {
+  const mulStr = String(multiplier)
+  return multiplier === 1 ? 0 : mulStr.length - 1
+}
+
 //this function converts the strNum into a integer * multiplier
-export const addPrecisionAsNumber = (strNum, multiplier) => {
+export const addPrecisionAsNumber = (strNum, multiplier, cachedDecimals) => {
   if (typeof strNum !== 'string') throw new Error('addPrecisionExact expects a string when precision=true')
 
   const negative = strNum.charAt(0) === '-'
@@ -60,8 +66,7 @@ export const addPrecisionAsNumber = (strNum, multiplier) => {
   const [intPart, decPart = ''] = s.split('.')
 
   // Compute decimals from multiplier (multiplier expected as 10^decimals)
-  const mulStr = String(multiplier);
-  const decimals = (multiplier === 1) ? 0 : (mulStr.length - 1)
+  const decimals = cachedDecimals === undefined ? getPrecisionDecimals(multiplier) : cachedDecimals
 
   const decPadded = decPart.padEnd(decimals, '0').slice(0, decimals); // pad or trim
   const integerString = intPart + decPadded // e.g. "12" + "3400" => "123400"
@@ -75,7 +80,7 @@ export const addPrecisionAsNumber = (strNum, multiplier) => {
 
 
 //this function converts the outputs the number generated in addPrecisionAsNumber / multiplier
-export const revertPrecisionAsNumber = (num, multiplier) => {
+export const revertPrecisionAsNumber = (num, multiplier, cachedDecimals) => {
   if (typeof num !== 'number' || !Number.isFinite(num)) {
     throw new Error('revertPrecisionAsNumber expects a finite number')
   }
@@ -86,7 +91,7 @@ export const revertPrecisionAsNumber = (num, multiplier) => {
   // Make sure we're working with an integer, mirroring addPrecisionAsNumber
   abs = Math.trunc(abs)
 
-  const decimals = (multiplier === 1) ? 0 : (String(multiplier).length - 1)
+  const decimals = cachedDecimals === undefined ? getPrecisionDecimals(multiplier) : cachedDecimals
 
   if (decimals === 0) {
     // No fractional part; just restore sign
@@ -106,4 +111,4 @@ export const revertPrecisionAsNumber = (num, multiplier) => {
     : `${intPart}.${fracStr}`
 
   return Number(negative ? `-${resultStr}` : resultStr)
-}
+}

package/src/utilities/verticalToHorizontal.js

@@ -1,5 +1,6 @@
 import { dateOutputFormaters } from "./dateUtilities.js" 
 import { outputNumberFormatter } from "./numberUtilities.js"
+import { getPrecisionDecimals } from "./precisionMultiplier.js"
 
 export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, dateFormat}) => {
 
@@ -8,6 +9,10 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
   
 
   if (verticalOhlcvKeyNames.length === 0) return []
+
+  const precisionDecimals = precision && typeof precisionMultiplier === 'number'
+    ? getPrecisionDecimals(precisionMultiplier)
+    : undefined
   
   const skipNullIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0
   const maxStartIndex = Math.max(skipNullIndex, startIndex)
@@ -33,7 +38,7 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
         const value = arr[i]
         result[i - maxStartIndex][key] = value == null || Number.isNaN(value)
           ? value
-          : formatter(value, precisionMultiplier)
+          : formatter(value, precisionMultiplier, precisionDecimals)
       }
     }
     else

package/src/volatility/atr.js

@@ -16,7 +16,7 @@ export const atr = (main, index, size, {lag, retLogs}) => {
 
     instances[baseKeyName] = new FasterATR(size, FasterWSMA)
 
-    initializeColumns(main, [{ key: baseKeyName, priceBased: true }], { lag })
+    initializeColumns(main, [{ key: baseKeyName, priceBased: !retLogs }], { lag })
   }
 
   // Retrieve the current price value.