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

Senior

// 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

Master

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

Master

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

Author

Posts

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

You must be logged in to reply to this topic.

TradingView to ProRealTime Translation Center

New Reply

Author

Trader18 @trader18 Participant

Summary

This topic contains 2 replies,
has 3 voices, and was last updated by Iván González
2 weeks, 4 days ago.

Topic Details

Forum:	TradingView to ProRealTime Translation Center Forum
Started:	04/27/2026
Status:	Active
Attachments:	1 files

Expert Services

No recent search

Traducción a ProRealTime del indicador FDI-Adaptive

TradingView to ProRealTime Translation Center

Author

Summary

Topic Details

About personal data collected

Get Assistance

Assistance Type

Your Need

Proposed Solutions

Choose Assistance Type

Your Need

Programming Help

Download Codes

Trading Help

ProRealTime Information

Account Assistance

Paid Programming Help