Traducción a ProRealTime del indicador FDI-Adaptive

Viewing 3 posts - 1 through 3 (of 3 total)

Author

Posts

04/27/2026 at 7:02 PM #260657 quote

Trader18

Participant

Veteran

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © loxx

//@version=5

indicator(“FDI-Adaptive, Jurik-Filtered, TMA w/ Price Zones [Loxx]”,

shorttitle=”FDIAJFTMAPZ [Loxx]”,

overlay = true,

timeframe=””,

timeframe_gaps = true)

import loxx/loxxjuriktools/1

import loxx/loxxexpandedsourcetypes/4

greencolor = #2DD204

redcolor = #D2042D

fdip(float src, int per, int speedin)=>

float fmax = ta.highest(src, per)

float fmin = ta.lowest(src, per)

float length = 0

float diff = 0

for i = 1 to per – 1

diff := (nz(src[i]) – fmin) / (fmax – fmin)

if i > 0

length += math.sqrt( math.pow(nz(diff[i]) – nz(diff[i + 1]), 2) + (1 / math.pow(per, 2)))

float fdi = 1 + (math.log(length) + math.log(2)) / math.log(2 * per)

float traildim = 1 / (2 – fdi)

float alpha = traildim / 2

int speed = math.round(speedin * alpha)

speed

calcrng(per)=>

float lsum = (per + 1) * low

float hsum = (per + 1) * high

float sumw = (per + 1)

int k = per

for j = 1 to per

lsum += k * nz(low[j])

hsum += k * nz(high[j])

sumw += k

k -= 1

float out = (hsum / sumw – lsum / sumw)

out

src = input.source(hl2, “Source”, group= “Source Settings”)

per = input.int(30, “Fractal Period Ingest”, group = “Basic Settings”)

speed = input.int(20, “Speed”, group = “Basic Settings”)

smthper = input.int(30, “Jurik Smoothing Period”, group = “Jurik Settings”)

smthphs = input.float(0., “Jurik Smoothing Phase”, group = “Jurik Settings”)

rngper = input.int(5, “Range Period”, group = “Price Zone Settings”)

dev = input.float(1.8, “Deviation”, group = “Price Zone Settings”)

colorbars = input.bool(true, “Color bars?”, group = “UI Options”)

showsignals = input.bool(true, “Show signals?”, group = “UI Options”)

fdiper = fdip(src, per, speed)

sum = (fdiper + 1) * src

sumw = (fdiper + 1)

k = fdiper

for j = 1 to fdiper

sum += k * nz(src[j])

sumw += k

k -= 1

tma = loxxjuriktools.jurik_filt(sum / sumw, smthper, smthphs)

sig = tma[1]

rng = calcrng(rngper)

uplvl = tma + dev * rng

dnlvl = tma – dev * rng

colorout = tma > sig ? greencolor : redcolor

plot(tma, “TMA”, color = colorout, linewidth = 3)

plot(uplvl, “Upper Channel”, color = color.gray, linewidth = 1)

plot(dnlvl, “Lower Channel”, color = color.gray, linewidth = 1)

barcolor(colorbars ? colorout : na)

goLong = ta.crossover(tma, sig)

goShort = ta.crossunder(tma, sig)

plotshape(goLong and showsignals, title = “Long”, color = color.yellow, textcolor = color.yellow, text = “L”, style = shape.triangleup, location = location.belowbar, size = size.tiny)

plotshape(goShort and showsignals, title = “Short”, color = color.fuchsia, textcolor = color.fuchsia, text = “S”, style = shape.triangledown, location = location.abovebar, size = size.tiny)

alertcondition(goLong, title=”Long”, message=”FDI-Adaptive, Jurik-Filtered, TMA w/ Price Zones [Loxx]: LongnSymbol: {{ticker}}nPrice: {{close}}”)

alertcondition(goShort, title=”Short”, message=”FDI-Adaptive, Jurik-Filtered, TMA w/ Price Zones [Loxx]]: ShortnSymbol: {{ticker}}nPrice: {{close}}”)

04/28/2026 at 9:47 AM #260674 quote

Nicolas

Keymaster

Legend

Please find attached below the translated code to prorealtime:

// FDI-Adaptive, Jurik-Filtered, TMA w/ Price Zones
// Converted from Pine Script (Loxx) to ProRealTime / ProBuilder
// Source: hl2 | All logic inlined (no external library dependencies)

// --- Settings ---
per       = 30   // Fractal Period Ingest
speed     = 20   // Speed
smthper   = 30   // Jurik Smoothing Period
smthphs   = 0    // Jurik Smoothing Phase (-100 to 100)
rngper    = 5    // Range Period
devMult   = 1.8  // Deviation multiplier
colorbars = 0    // Color bars: 1 = yes, 0 = no
showsig   = 1    // Show signals: 1 = yes, 0 = no

src = (high + low) / 2  // hl2 equivalent

if barindex>per+smthper then
   // -------------------------------------------------------
   // 1. FDI – Fractal Dimension Index -> adaptive period
   //    Measures the fractal dimension of src over [per] bars
   //    and maps it to a dynamic WMA speed.
   // -------------------------------------------------------
   fmax = highest[per](src)
   fmin = lowest[per](src)
   
   fdiLength = 0
   FOR i = 1 TO per - 1 DO
      diff   = (src[i] - fmin) / (fmax - fmin)
      arcLen = SQRT((diff - diff[1]) * (diff - diff[1]) + (1 / (per * per)))
      fdiLength = fdiLength + arcLen
   NEXT
   
   fdi      = 1 + (LOG(fdiLength) + LOG(2)) / LOG(2 * per)
   trailDim = 1 / (2 - fdi)
   alphaFDI = trailDim / 2
   fdiper   = ROUND(speed * alphaFDI)
   
   IF fdiper  [2.5, 0.5]
   //    beta = 0.45*(L-1)/(0.45*(L-1)+2)
   //    alpha = beta^2
   // -------------------------------------------------------
   IF smthphs >= 100 THEN
      phaseRatio = 0.5
   ELSIF smthphs <= -100 THEN
      phaseRatio = 2.5
   ELSE
      phaseRatio = smthphs / 100 + 1.5
   ENDIF
   
   betaJMA  = 0.45 * (smthper - 1) / (0.45 * (smthper - 1) + 2)
   alphaJMA = EXP(LOG(betaJMA) * 2)  // betaJMA^2 via log/exp
   
   IF barindex  sig THEN
      r = 45
      g = 210
      b = 4
   ELSE
      r = 210
      g = 4
      b = 45
   ENDIF
   
   // Bar colouring
   IF colorbars = 1 THEN
      DRAWCANDLE(open,high,low,close) coloured(r,g,b)
   ENDIF
   
   // Arrow signals
   IF showsig = 1 THEN
      IF goLong THEN
         DRAWARROWUP(barindex, low - rng * 0.5) COLOURED(255, 255, 0)
      ENDIF
      IF goShort THEN
         DRAWARROWDOWN(barindex, high + rng * 0.5) COLOURED(255, 0, 255)
      ENDIF
   ENDIF
   
endif

RETURN tma COLOURED(r, g, b) AS "TMA", uplvl COLOURED(128, 128, 128) AS "Upper Zone", dnlvl COLOURED(128, 128, 128) AS "Lower Zone"

DXSXXXX-1-hour.png

04/28/2026 at 10:09 AM #260676 quote

Iván González

Moderator

Legend

Hi! here you have

// PRC_FDI-Adaptive Jurik-Filtered TMA w/ Price Zones
// version = 0
// 28.04.26
// Ivan Gonzalez @ www.prorealcode.com
// Sharing ProRealTime knowledge
// Original: FDI-Adaptive, Jurik-Filtered, TMA w/ Price Zones [Loxx] (TradingView)
//////////////////////////////////////////////////////////////
// Inputs
src = (high+low)/2
per = 30
speedin = 20
smthper = 30
smthphs = 0.0
rngper = 5
dev = 1.8
colorbars = 1
showsignals = 1
//////////////////////////////////////////////////////////////
// === FDI calculation — period adaptive via Fractal Dimension Index
fmax = highest[per](src)
fmin = lowest[per](src)


IF fmax > fmin THEN
    fdiLen = 0
    FOR i = 1 TO per - 1 DO
        diffCurr = (src[i-1] - fmin) / (fmax - fmin)
        diffPrev = (src[i] - fmin) / (fmax - fmin)
        fdiLen = fdiLen + sqrt((diffCurr - diffPrev)*(diffCurr - diffPrev) + 1/(per*per))
    NEXT
    IF fdiLen > 0 THEN
        fdi = 1 + (log(fdiLen) + log(2)) / log(2 * per)
    ELSE
        fdi = 1.5
    ENDIF
ELSE
    fdi = 1.5
ENDIF


IF fdi < 2 THEN
    traildim = 1 / (2 - fdi)
ELSE
    traildim = 1
ENDIF
alphaFdi = traildim / 2
fdiper = round(speedin * alphaFdi)
IF fdiper < 1 THEN
    fdiper = 1
ENDIF
IF fdiper > 200 THEN
    fdiper = 200
ENDIF
//////////////////////////////////////////////////////////////
// === Triangular weighted MA with adaptive period
sumv = (fdiper + 1) * src
sumw = (fdiper + 1)
k = fdiper
FOR j = 1 TO fdiper DO
    sumv = sumv + k * src[j]
    sumw = sumw + k
    k = k - 1
NEXT
tmaRaw = sumv / sumw
//////////////////////////////////////////////////////////////
// === Jurik MA filter applied to tmaRaw
len = max(smthper, 1)
phs = smthphs
len1 = max(log(sqrt(0.5*(len-1)))/log(2)+2, 0)
pow1 = max(len1-2, 0.5)
avglen = 65


IF barindex < avglen+1 THEN
    Filt0jk = tmaRaw
    Filt1jk = tmaRaw
    juriktma = tmaRaw
    bsmaxjk = 0
    bsminjk = 0
    vsumjk = 0
    avoltyjk = 0
ELSE
    del1jk = tmaRaw - bsmaxjk[1]
    del2jk = tmaRaw - bsminjk[1]
    div = 1/(10+10*(min(max(len-10,0),100))/100)
    IF abs(del1jk) > abs(del2jk) THEN
        voltyjk = abs(del1jk)
    ELSE
        voltyjk = abs(del2jk)
    ENDIF
    vsumjk = vsumjk[1] + div*(voltyjk - voltyjk[10])


    tempavgjk = average[avglen](vsumjk)


    yjk = barindex+1
    IF yjk <= avglen+1 THEN
        avoltyjk = avoltyjk[1] + 2*(vsumjk-avoltyjk[1])/(avglen+1)
    ELSE
        avoltyjk = tempavgjk
    ENDIF


    IF avoltyjk > 0 THEN
        dvoltyjk = voltyjk/avoltyjk
    ELSE
        dvoltyjk = 0
    ENDIF


    IF dvoltyjk > pow(len1,1/pow1) THEN
        dvoltyjk = pow(len1,1/pow1)
    ENDIF
    IF dvoltyjk < 1 THEN
        dvoltyjk = 1
    ENDIF


    pow2jk = pow(dvoltyjk, pow1)
    len2 = sqrt(0.5*(len-1))*len1
    kvjk = pow(len2/(len2+1), sqrt(pow2jk))


    IF del1jk > 0 THEN
        bsmaxjk = tmaRaw
    ELSE
        bsmaxjk = tmaRaw - kvjk*del1jk
    ENDIF


    IF del2jk < 0 THEN
        bsminjk = tmaRaw
    ELSE
        bsminjk = tmaRaw - kvjk*del2jk
    ENDIF


    IF phs < -100 THEN
        phaseratio = 0.5
    ELSIF phs > 100 THEN
        phaseratio = 2.5
    ELSE
        phaseratio = phs/100+1.5
    ENDIF


    beta = 0.45 * (len - 1) / (0.45 * (len - 1) + 2)
    alphajk = pow(beta, pow2jk)


    Filt0jk = (1 - alphajk) * tmaRaw + alphajk * Filt0jk[1]
    Det0jk = (tmaRaw - Filt0jk) * (1 - beta) + beta * Det0jk[1]
    Filt1jk = Filt0jk + phaseratio * Det0jk
    Det1jk = (Filt1jk - juriktma[1]) * ((1 - alphajk) * (1 - alphajk)) + (alphajk * alphajk) * Det1jk[1]
    juriktma = juriktma[1] + Det1jk
ENDIF


tma = juriktma
sig = tma[1]
//////////////////////////////////////////////////////////////
// === Range calculation (calcrng) — triangular weighted high-low spread
lsum = (rngper + 1) * low
hsum = (rngper + 1) * high
sumwr = (rngper + 1)
kr = rngper
FOR jr = 1 TO rngper DO
    lsum = lsum + kr * low[jr]
    hsum = hsum + kr * high[jr]
    sumwr = sumwr + kr
    kr = kr - 1
NEXT
rng = (hsum - lsum) / sumwr
//////////////////////////////////////////////////////////////
// === Price zones
uplvl = tma + dev * rng
dnlvl = tma - dev * rng
//////////////////////////////////////////////////////////////
// === Color (TMA up/down)
IF tma > sig THEN
    r = 45
    g = 210
    b = 4
ELSE
    r = 210
    g = 4
    b = 45
ENDIF
//////////////////////////////////////////////////////////////
// === Color bars (replica barcolor de Pine)
IF colorbars = 1 THEN
    drawcandle(open,high,low,close) coloured(r,g,b)
ENDIF
//////////////////////////////////////////////////////////////
// === Signals
goLong = tma CROSSES OVER sig
goShort = tma CROSSES UNDER sig


IF showsignals = 1 AND goLong THEN
    drawtext("▲", barindex, low - 0.3*rng) coloured(0,255,255)
ENDIF
IF showsignals = 1 AND goShort THEN
    drawtext("▼", barindex, high + 0.3*rng) coloured(255,0,255)
ENDIF
//////////////////////////////////////////////////////////////
return tma coloured(r,g,b) style(line,3) as "TMA", uplvl coloured(120,120,120) as "Upper Channel", dnlvl coloured(120,120,120) as "Lower Channel"

Nicolas thanked this post