ohlcv-indicators 3.5.77 → 3.5.79

package/src/machine-learning/scaler.js

@@ -1,165 +0,0 @@
-import { normalizeMinMax, normalizeZScore } from "./ml-utilities.js";
-
-const isBadNumber = (v) => v == null || !Number.isFinite(v)
-
-//rowWiseScaler
-
-export const scaler = (main, index, size, colKeys, {type, minMaxRange, lookback, weights, euclideanWeights, byFeatureRange, offset}) => {
-
-    //this function performs scaling row by row "row wise scaling"
-
-    const { verticalOhlcv, instances } = main
-    const prefix = `${type}_${size}`
-  
-    if(index === 0) {
-      const { len, isAlreadyComputed } = main
-
-      if(isAlreadyComputed.has(prefix))
-      {
-        throw new Error(`In scaler method can not repeat params "size" and "options.type" together between indicators.`)
-      }
-  
-      if(!instances.hasOwnProperty('scaler')) {
-        instances.scaler = {}
-      }
-
-      if(!instances.scaler.hasOwnProperty(prefix))
-      {
-        instances.scaler[prefix] = {
-          extectedFeatures: (lookback === 0) ? colKeys.length : colKeys.length + (lookback * colKeys.length)
-        }
-      }
-
-      const features = []
-
-      for (const target of colKeys) {
-        if (!verticalOhlcv.hasOwnProperty(target)) {
-          throw new Error(`Target property "${target}" not found in verticalOhlcv`);
-        }
-  
-        const key = `${prefix}_${target}`;
-        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-  
-        if (!main.scaledGroups[prefix]) main.scaledGroups[prefix] = [];
-
-        main.scaledGroups[prefix].push(key);
-  
-        if (lookback > 0) {
-          const laggedKeys = Array.from({ length: lookback }).map((_, i) => `${key}_lag_${i + 1}`)
-
-          for(const lKey of laggedKeys) {
-            verticalOhlcv[lKey] = new Float64Array(len).fill(NaN)
-          }
-
-          main.scaledGroups[prefix].push(...laggedKeys)
-          features.push(key)
-        }
-      }
-
-      for(const weKey of Object.keys(weights)) {
-        if (!verticalOhlcv.hasOwnProperty(weKey)) {
-          throw new Error(`Target property "${weKey}" not found in verticalOhlcv`);
-        }
-      }
-
-    }
-  
-    const { extectedFeatures } = instances.scaler[prefix]
-    
-    let hasInvalidVal = false
-    const row = {}
-    const rowValues = []
-    let countFeatures = 0
-
-    const sourceIndex = index - offset
-
-    if(sourceIndex < 0) return 
-
-   
-
-    for (let x = 0; x < colKeys.length; x++) {
-      const target = colKeys[x]
-      const col = verticalOhlcv[target]
-      const currWeight = weights?.[target]?.[0] ?? 1
-      const currVal = col[sourceIndex]
-
-      if(isBadNumber(currVal))
-      {
-        hasInvalidVal = true
-        break
-      }
-
-      row[target] = {
-        val: currVal, 
-        weight: (euclideanWeights) ? Math.sqrt(currWeight) :  currWeight
-      }
-
-      rowValues.push(currVal)
-      countFeatures++
-
-      if(lookback > 0) {
-        for (let step = 1; step <= lookback; step++) {
-
-          const laggedWeight = weights?.[target]?.[step] ?? 1
-          const laggedVal = col[sourceIndex - step]
-
-          if(isBadNumber(laggedVal))
-          {
-            hasInvalidVal = true
-            break
-          }
-
-          row[`${target}_lag_${step}`] = {
-            val: laggedVal, 
-            weight: (euclideanWeights) ? Math.sqrt(laggedWeight) : laggedWeight
-          }
-
-          rowValues.push(laggedVal)
-          countFeatures++
-        }
-
-        if(hasInvalidVal) break
-      }
-    }
-
-    if(hasInvalidVal || countFeatures !== extectedFeatures) return
-
-    if (type === "minmax") {
-      const mn = Math.min(...rowValues);
-      const mx = Math.max(...rowValues);
-
-      for (const [key, { val, weight }] of Object.entries(row)) {
-        const scaled = normalizeMinMax(val, mn, mx, minMaxRange)
-        const weigthed = scaled === 0 ? 0 : scaled * weight
-        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
-      }
-    }
-
-    if (type === "zscore") {
-      const n = rowValues.length;
-      const mean = rowValues.reduce((s, x) => s + x, 0) / n;
-      const variance = rowValues.reduce((s, x) => s + (x - mean) ** 2, 0) / n;
-      const std = Math.sqrt(variance);
-
-      for (const [key, { val, weight }] of Object.entries(row)) {
-        const scaled = normalizeZScore(val, mean, std)
-        const weigthed = scaled === 0 ? 0 : scaled * weight
-        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
-      }
-    }
-
-    if(type === "byfeature") {
-
-      const [mn, mx] = byFeatureRange
-
-      for (const [key, { val, weight }] of Object.entries(row)) {
-
-        const scaled = normalizeMinMax(val, mn, mx, minMaxRange)
-        const weigthed = scaled === 0 ? 0 : scaled * weight
-
-        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
-      }
-
-    }
-}
-  

package/src/moving-averages/vidya.js

@@ -1,181 +0,0 @@
-import { FasterSMA } from 'trading-signals';
-// Variable Index Dynamic Average (VIDYA) indicator with volume stats
-
-export const vidya = (main, index, size, momentum, options = {}) => {
-  const { verticalOhlcv, instances, len, priceBased } = main;
-  const { target, lag, atrLength = 200, bandDistance = 2, liquidityLookback = 5 } = options
-  const indicatorKey = `${size}_${momentum}`;
-
-  // Initialization on the first bar
-  if (index === 0) {
-    if (!(target in verticalOhlcv)) {
-      throw new Error(`VIDYA could not find target "${target}"`)
-    }
-
-    const prefix = `vidya_${indicatorKey}`
-    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`
-    const keys = {
-      vidya: keyBase,
-      upper: `${prefix}_upper`, 
-      lower: `${prefix}_lower`,
-      delta_vol: `${prefix}_delta_vol`,
-      cross: `${prefix}_cross`,
-      liquidity: `${prefix}_liquidity`,
-    }
-
-    const priceBasedVidyaKeys = [keyBase, keys.upper, keys.lower, keys.liquidity]
-
-    for(const k of priceBasedVidyaKeys) {
-      priceBased.add(k)
-    }
-
-    // Prepare instances container
-    if (!instances.vidya) instances.vidya = { settings: {} };
-    instances.vidya.settings[indicatorKey] = {
-      momentumBuffer: [], prevVidya: NaN,
-      sma: new FasterSMA(15), atrBuffer: [],
-      isTrendUp: false, upVol: 0, downVol: 0,
-      liquidity: {
-        high: [],
-        low: []
-      }
-    };
-
-    // Allocate output arrays
-    Object.values(keys).forEach(key => {
-      verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-    })
-    
-    if (lag > 0) main.lag(Object.values(keys), lag);
-  }
-
-  // Per-bar computation
-  const inst = instances.vidya.settings[indicatorKey];
-  const prefix = `vidya_${indicatorKey}`;
-  const keyBase = target === 'close' ? prefix : `${prefix}_${target}`;
-  const keys = {
-    vidya: keyBase,
-    upper: `${prefix}_upper`, 
-    lower: `${prefix}_lower`,
-    delta_vol: `${prefix}_delta_vol`,
-    cross: `${prefix}_cross`,
-    liquidity: `${prefix}_liquidity`,
-  };
-
-  // Series inputs
-  const price = verticalOhlcv[target][index]
-  const high  = verticalOhlcv.high[index]
-  const low   = verticalOhlcv.low[index]
-  const close = verticalOhlcv.close[index]
-  const open  = verticalOhlcv.open[index]
-  const vol   = verticalOhlcv.volume[index]
-  const prevCross = index > 0 ? verticalOhlcv[keys.cross][index - 1] : 0
-
-  const highestHigh = (inst.liquidity.high.length === liquidityLookback) ? Math.max(...inst.liquidity.high) : NaN
-  const lowestLow = (inst.liquidity.low.length === liquidityLookback) ? Math.min(...inst.liquidity.low) : NaN
-
-  // Compute ATR (Wilder's RMA)
-  if (index > 0) {
-    const prevClose = verticalOhlcv.close[index - 1];
-    const tr = Math.max(
-      high - low,
-      Math.abs(high - prevClose),
-      Math.abs(low - prevClose)
-    )
-    inst.atrBuffer.push(tr)
-    if (inst.atrBuffer.length > atrLength) inst.atrBuffer.shift()
-  }
-  const atr = inst.atrBuffer.length === atrLength
-    ? inst.atrBuffer.reduce((a, b) => a + b, 0) / atrLength
-    : NaN
-
-  // Compute raw VIDYA
-  let rawVidya = NaN
-  let mom = NaN
-  if (index > 0) mom = price - verticalOhlcv[target][index - 1]
-  inst.momentumBuffer.push(mom)
-  if (inst.momentumBuffer.length > momentum) inst.momentumBuffer.shift()
-  if (inst.momentumBuffer.length === momentum) {
-    let sumPos = 0, sumNeg = 0
-    inst.momentumBuffer.forEach(m => m >= 0 ? sumPos += m : sumNeg += -m);
-    const denom = sumPos + sumNeg
-    const cmo = denom === 0 ? 0 : Math.abs((sumPos - sumNeg) / denom) * 100;
-    const alpha = 2 / (size + 1)
-    const a = alpha * (cmo / 100)
-    rawVidya = isNaN(inst.prevVidya) ? price : (a * price + (1 - a) * inst.prevVidya);
-    inst.prevVidya = rawVidya
-  }
-
-  // Smooth VIDYA using fixed 15-bar SMA
-  inst.sma.update(rawVidya)
-  let smoothedVidya = NaN
-  try { smoothedVidya = inst.sma.getResult() } catch {}
-
-  // Bands
-  const upper = (!isNaN(atr) && !isNaN(smoothedVidya))
-    ? smoothedVidya + atr * bandDistance
-    : NaN
-  const lower = (!isNaN(atr) && !isNaN(smoothedVidya))
-    ? smoothedVidya - atr * bandDistance
-    : NaN
-
-  // Detect crosses
-  const prevPrice = index > 0 ? verticalOhlcv[target][index - 1] : NaN
-  const prevUpper = index > 0 ? verticalOhlcv[keys.upper][index - 1] : NaN
-  const prevLower = index > 0 ? verticalOhlcv[keys.lower][index - 1] : NaN
-  const crossUp   = index > 0 && prevPrice <= prevUpper && price > upper
-  const crossDown = index > 0 && prevPrice >= prevLower && price < lower
-
-  // Update trend state
-  if (crossUp) inst.isTrendUp = true
-  if (crossDown) inst.isTrendUp = false
-
-  // Cumulative cross counter: positive when uptrend, negative when downtrend
-  let cross = 0;
-  if (index > 0) {
-    if (inst.isTrendUp) {
-      cross = prevCross > 0 ? prevCross + 1 : 1
-    } else {
-      cross = prevCross < 0 ? prevCross - 1 : -1
-    }
-  }
-
-  // Volume accumulation
-  if (crossUp || crossDown) {
-    inst.upVol = inst.downVol = 0
-  } else {
-    inst.upVol   += (close > open ? vol : 0)
-    inst.downVol += (close < open ? vol : 0)
-  }
-  const avgVol = (inst.upVol + inst.downVol) / 2 || 1
-  const deltaPct = (inst.upVol - inst.downVol) / avgVol
-
-  // Trend-based boundary (reset on crossover)
-  const trendValue = (inst.isTrendUp) ? lower : upper
-  let liquidity = NaN
-
-  if(cross > 0)
-  {
-    liquidity = lowestLow
-  }
-  else if(cross < 0)
-  {
-    liquidity = highestHigh
-  }
-
-  // Push outputs
-  main.pushToMain({ index, key: keys.vidya, value: trendValue })
-  main.pushToMain({ index, key: keys.upper, value: upper })
-  main.pushToMain({ index, key: keys.lower, value: lower })
-  main.pushToMain({ index, key: keys.delta_vol, value: deltaPct })
-  main.pushToMain({ index, key: keys.cross, value: cross })
-  main.pushToMain({ index, key: keys.liquidity, value: liquidity })
-
-  inst.liquidity.high.push(high)
-  inst.liquidity.low.push(low)
-
-  if(inst.liquidity.high.length > liquidityLookback) inst.liquidity.high.shift()
-  if(inst.liquidity.low.length > liquidityLookback) inst.liquidity.low.shift()
-
-  return true
-}