Conversion of Jurik DMX Histogram Indicator from Trading View

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

Author

Posts

01/17/2024 at 12:17 PM #226461 quote

Participant

Average

Please could you convert the below Trading View code found on the following website: Jurik DMX Histogram [Loxx] — Indicator by loxx — TradingView

Jurik DMX Histogram is the ultra-smooth, low lag version of your classic DMI indicator.

//@version=5
indicator(title=”Jurik DMX Histogram [Loxx]”, shorttitle=”JDMXH [Loxx]”, timeframe=””, timeframe_gaps=true, overlay = false)

greencolor = #2DD204
redcolor = #D2042D
bluecolor = #042dd2

lightgreencolor = #96E881
lightredcolor = #DF4F6C
lightbluecolor = #4f6cdf

darkGreenColor = #1B7E02
darkRedColor = #93021F
darkBlueColor = #021f93

_f_hp(_src, max_len) =>
var c = 360 * math.pi / 180
_alpha = (1 – math.sin(c / max_len)) / math.cos(c / max_len)
_hp = 0.0
_hp := 0.5 * (1 + _alpha) * (_src – nz(_src[1])) + _alpha * nz(_hp[1])
_hp

_f_ess(_src, _len) =>
var s = 1.414
_a = math.exp(-s * math.pi / _len)
_b = 2 * _a * math.cos(s * math.pi / _len)
_c2 = _b
_c3 = -_a * _a
_c1 = 1 – _c2 – _c3
_out = 0.0
_out := _c1 * (_src + nz(_src[1])) / 2 + _c2 * nz(_out[1], nz(_src[1], _src)) + _c3 * nz(_out[2], nz(_src[2], nz(_src[1], _src)))
_out

_auto_dom(src, min_len, max_len, ave_len) =>
var c = 2 * math.pi
var s = 1.414
avglen = ave_len

filt = _f_ess(_f_hp(src, max_len), min_len)
arr_size = max_len * 2

var corr = array.new_float(arr_size, initial_value=0)
var cospart = array.new_float(arr_size, initial_value=0)
var sinpart = array.new_float(arr_size, initial_value=0)
var sqsum = array.new_float(arr_size, initial_value=0)
var r1 = array.new_float(arr_size, initial_value=0)
var r2 = array.new_float(arr_size, initial_value=0)
var pwr = array.new_float(arr_size, initial_value=0)

for lag = 0 to max_len by 1
m = avglen == 0 ? lag : avglen
Sx = 0.0, Sy = 0.0, Sxx = 0.0, Syy = 0.0, Sxy = 0.0
for i = 0 to m – 1 by 1
x = nz(filt[i])
y = nz(filt[lag + i])
Sx += x
Sy += y
Sxx += x * x
Sxy += x * y
Syy += y * y
Syy
if (m * Sxx – Sx * Sx) * (m * Syy – Sy * Sy) > 0
array.set(corr, lag, (m * Sxy – Sx * Sy) / math.sqrt((m * Sxx – Sx * Sx) * (m * Syy – Sy * Sy)))

for period = min_len to max_len by 1
array.set(cospart, period, 0)
array.set(sinpart, period, 0)
for n = ave_len to max_len by 1
array.set(cospart, period, nz(array.get(cospart, period)) + nz(array.get(corr, n)) * math.cos(c * n / period))
array.set(sinpart, period, nz(array.get(sinpart, period)) + nz(array.get(corr, n)) * math.sin(c * n / period))
array.set(sqsum, period, math.pow(nz(array.get(cospart, period)), 2) + math.pow(nz(array.get(sinpart, period)), 2))

for period = min_len to max_len by 1
array.set(r2, period, nz(array.get(r1, period)))
array.set(r1, period, 0.2 * math.pow(nz(array.get(sqsum, period)), 2) + 0.8 * nz(array.get(r2, period)))

maxpwr = 0.0

for period = min_len to max_len by 1
if nz(array.get(r1, period)) > maxpwr
maxpwr := nz(array.get(r1, period))

for period = ave_len to max_len by 1
array.set(pwr, period, nz(array.get(r1, period)) / maxpwr)

dominantcycle = 0.0, peakpwr = 0.0

for period = min_len to max_len by 1
if nz(array.get(pwr, period)) > peakpwr
peakpwr := nz(array.get(pwr, period))

spx = 0.0, sp = 0.0

for period = min_len to max_len by 1
if peakpwr >= 0.25 and nz(array.get(pwr, period)) >= 0.25
spx += period * nz(array.get(pwr, period))
sp += nz(array.get(pwr, period))

dominantcycle := sp != 0 ? spx / sp : dominantcycle
dominantcycle := sp < 0.25 ? dominantcycle[1] : dominantcycle
dominantcycle := dominantcycle < 1 ? 1 : dominantcycle
dom_in = math.min(math.max(dominantcycle, min_len), max_len)
dom_in

_a_jurik_filt(src, len, phase) =>
len1 = math.max(math.log(math.sqrt(0.5 * (len-1))) / math.log(2.0) + 2.0, 0)
pow1 = math.max(len1 – 2.0, 0.5)
volty = 7.0, avolty = 9.0, vsum = 8.0, bsmax = 5.0, bsmin = 6.0, avgLen = 65

del1 = src – nz(bsmax[1])
del2 = src – nz(bsmin[1])

div = 1.0 / (10.0 + 10.0 * (math.min(math.max(len-10, 0), 100)) / 100)
volty := math.abs(del1) > math.abs(del2) ? math.abs(del1) : math.abs(del2)
vsum := nz(vsum[1]) + div * (volty – nz(volty[10]))

temp_avg = ta.sma(vsum, avgLen)

y = bar_index + 1
if(y <= avgLen + 1)
avolty := nz(avolty[1]) + 2.0 * (vsum – nz(avolty[1])) / (avgLen + 1)
else
avolty := temp_avg

dVolty = avolty > 0 ? volty / avolty : 0
dVolty := dVolty > math.pow(len1, 1.0/pow1) ? math.pow(len1, 1.0/pow1) : dVolty
dVolty := dVolty < 1 ? 1 : dVolty
pow2 = math.pow(dVolty, pow1)
len2 = math.sqrt(0.5 * (len – 1)) * len1
Kv = math.pow(len2 / (len2 + 1), math.sqrt(pow2))

bsmax := del1 > 0 ? src : src – Kv * del1
bsmin := del2 < 0 ? src : src – Kv * del2

phaseRatio = phase < -100 ? 0.5 : phase > 100 ? 2.5 : phase / 100 + 1.5
beta = 0.45 * (len – 1) / (0.45 * (len – 1) + 2)
alpha = math.pow(beta, pow2)
jma1 = 0.0, e0 = 0.0, e1 = 0.0, e2 = 0.0
e0 := (1 – alpha) * src + alpha * nz(e0[1])
e1 := (src – e0) * (1 – beta) + beta * nz(e1[1])
e2 := (e0 + phaseRatio * e1 – nz(jma1[1])) * math.pow(1 – alpha, 2) + math.pow(alpha, 2) * nz(e2[1])
jma1 := e2 + nz(jma1[1])
jma1

adapt = input.string(“Fixed”, “Calculation type”, options = [“Fixed”, “Autocorrelation Adaptive”], group = “Basic Settings”)

len = input.int(32, minval=1, title=”Length”, group = “Basic Settings”)
phs = input.int(0, title= “Jurik Phase”, group = “Basic Settings”)
siglen = input.int(5, minval=1, title=”Signal Smoothing Length”, group = “Basic Settings”)

auto_src = input.source(close, title=’JMA Source’, group = “Autocorrelation Periodgram Algorithm”)
auto_min = input.int(8, minval = 1, title=’JMA Min Length’, group = “Autocorrelation Periodgram Algorithm”)
auto_max = input.int(50, minval = 1, title=’JMA Max Length’, group = “Autocorrelation Periodgram Algorithm”)
auto_avg = input.int(32, minval = 1, title=’JMA Average Length’, group = “Autocorrelation Periodgram Algorithm”)

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

auto = _auto_dom(auto_src, auto_min, auto_max, auto_avg)
out = adapt == “Fixed” ? len : int(auto) < 1 ? 1 : int(auto)

up = ta.change(high)
down = -ta.change(low)

plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)

trur = _a_jurik_filt(ta.tr, out, phs)

plus = fixnan(100 * _a_jurik_filt(plusDM, out, phs) / trur)
minus = fixnan(100 * _a_jurik_filt(minusDM, out, phs) / trur)

trigger = plus-minus
signal = _a_jurik_filt(trigger, siglen, phs)

colorout =
trigger >= 0 and trigger >= signal ? greencolor :
trigger >= 0 and trigger < signal ? lightgreencolor :
trigger < 0 and trigger < signal ? redcolor :
lightredcolor

plot(trigger, color=colorout, title = “DMX”, style = plot.style_histogram)
plot(trigger, color = trigger >= 0 ? darkGreenColor : darkRedColor , title = “DMX”, linewidth = 1)
plot(signal, color = color.white, title = “Signal”, linewidth = 2)

barcolor(colorbars ? colorout : na)

Jurik-DMX-Histogram.png

03/13/2024 at 1:46 PM #229698 quote

Iván González

Moderator

Master

Hi,
Here it’s the code: https://www.prorealcode.com/prorealtime-indicators/jurik-dmx-histogram-indicator/

//PRC_Jurik DMX Histogram
//version = 0
//13.03.24
//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge
/////////////////////////////////////////////////////////////////////
///inputs////////////////////////////////////
siglen = 5 // Signal Smoothing length
phs = 0 //Jurik Phase
len = 32 //Length
////////////////////////////////////////////
len = MAX(len, 1)
len1 = max(log(sqrt(0.5*(len-1)))/log(2)+2,0)
Pow1 = max(len1-2,0.5)
avglen = 65
//////PlusDM and MinusDM////////////////////
if barindex=0 then
up = high
down = high
else
up = high-high[1]
down = -(low-low[1])
endif
if up > down and up > 0 then
plusDM = up
else
plusDM = 0
endif
if down > up and down > 0 then
minusDM = down
else
minusDM = 0
endif
////////////////////////////////
//TRUR - JURIK AVERAGE
IF BarIndex < avglen+1 THEN
Filt0tr = tr
Filt1tr = tr
trur = tr
bsmaxtr = 0
bsmintr = 0
vsumtr = 0
avoltytr = 0
ELSE
del1tr = tr-bsmaxtr[1]
del2tr = tr-bsmintr[1]
div = 1/(10+10*(min(max(len-10,0),100))/100)
if abs(del1tr)>abs(del2tr) then
voltytr = abs(del1tr)
else
voltytr = abs(del2tr)
endif
vsumtr = vsumtr[1]+div*(voltytr-voltytr[10])

tempavgtr = average[avglen](vsumtr)

y= barindex+1
if (y <= avglen+1) then
avoltytr = avoltytr[1]+2*(vsumtr-avoltytr[1])/(avglen+1)
else
avoltytr = tempavgtr
endif

if avoltytr > 0 then
dvoltytr = voltytr/avoltytr
else
dvoltytr = 0
endif

if dvoltytr > pow(len1,1/pow1) then
dvoltytr = pow(len1,1/pow1)
else
dvoltytr = dvoltytr
endif

if dvoltytr < 1 then
dvoltytr= 1
else
dvoltytr = dvoltytr
endif

pow2tr = pow(dvoltytr,pow1)
len2 = sqrt(0.5*(len-1))*len1
kvtr = pow(len2/(len2+1),sqrt(pow2tr))

if del1tr > 0 then
bsmaxtr = tr
else
bsmaxtr = tr - kvtr*del1tr
endif

if del2tr < 0 then
bsmintr = tr
else
bsmintr = tr - kvtr*del2tr
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)
alphatr = pow(beta,pow2tr)

Filt0tr = (1 - alphatr) * tr + alphatr * Filt0tr[1]
Det0tr = (tr - Filt0tr[0]) * (1 - beta) + beta * Det0tr[1]
Filt1tr = Filt0tr[0] + phaseratio * Det0tr[0]
Det1tr = (Filt1tr[0] - trur[1]) * ((1 - alphatr) * (1 - alphatr)) + (alphatr * alphatr) * Det1tr[1]
trur = trur[1] + Det1tr[0]
ENDIF
/////Plus
IF BarIndex < avglen+1 THEN
Filt0pl = 0
Filt1pl = 0
jurikPlus = 0
bsmaxpl = 0
bsminpl = 0
vsumpl = 0
avoltypl = 0
ELSE
del1pl = plusDM-bsmaxpl[1]
del2pl = plusDM-bsminpl[1]
div = 1/(10+10*(min(max(len-10,0),100))/100)
if abs(del1pl)>abs(del2pl) then
voltypl = abs(del1pl)
else
voltypl = abs(del2pl)
endif
vsumpl = vsumpl[1]+div*(voltypl-voltypl[10])

tempavgpl = average[avglen](vsumpl)

y= barindex+1
if (y <= avglen+1) then
avoltypl = avoltypl[1]+2*(vsumpl-avoltypl[1])/(avglen+1)
else
avoltypl = tempavgpl
endif

if avoltypl > 0 then
dvoltypl = voltypl/avoltypl
else
dvoltypl = 0
endif

if dvoltypl > pow(len1,1/pow1) then
dvoltypl = pow(len1,1/pow1)
else
dvoltypl = dvoltypl
endif

if dvoltypl < 1 then
dvoltypl= 1
else
dvoltypl = dvoltypl
endif

pow2pl = pow(dvoltypl,pow1)
len2 = sqrt(0.5*(len-1))*len1
kvpl = pow(len2/(len2+1),sqrt(pow2pl))

if del1pl > 0 then
bsmaxpl = plusDM
else
bsmaxpl = plusDM - kvpl*del1pl
endif

if del2pl < 0 then
bsminpl = plusDM
else
bsminpl = plusDM - kvpl*del2pl
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)
alphapl = pow(beta,pow2pl)

Filt0pl = (1 - alphapl) * plusDM + alphapl * Filt0pl[1]
Det0pl = (plusDM - Filt0pl[0]) * (1 - beta) + beta * Det0pl[1]
Filt1pl = Filt0pl[0] + phaseratio * Det0pl[0]
Det1pl = (Filt1pl[0] - jurikPlus[1]) * ((1 - alphapl) * (1 - alphapl)) + (alphapl * alphapl) * Det1pl[1]
jurikPlus = jurikPlus[1] + Det1pl[0]
ENDIF

plus = (100*jurikPlus/trur)

///////////////////////////////////////////////
/////minus
IF BarIndex < avglen+1 THEN
Filt0mn = 0
Filt1mn = 0
jurikMinus = 0
bsmaxmn = 0
bsminmn = 0
vsummn = 0
avoltymn = 0
ELSE
del1mn = minusDM-bsmaxmn[1]
del2mn = minusDM-bsminmn[1]
div = 1/(10+10*(min(max(len-10,0),100))/100)
if abs(del1mn)>abs(del2mn) then
voltymn = abs(del1mn)
else
voltymn = abs(del2mn)
endif
vsummn = vsummn[1]+div*(voltymn-voltymn[10])

tempavgmn = average[avglen](vsummn)

y= barindex+1
if (y <= avglen+1) then
avoltymn = avoltymn[1]+2*(vsummn-avoltymn[1])/(avglen+1)
else
avoltymn = tempavgmn
endif

if avoltymn > 0 then
dvoltymn = voltymn/avoltymn
else
dvoltymn = 0
endif

if dvoltymn > pow(len1,1/pow1) then
dvoltymn = pow(len1,1/pow1)
else
dvoltymn = dvoltymn
endif

if dvoltymn < 1 then
dvoltymn= 1
else
dvoltymn = dvoltymn
endif

pow2mn = pow(dvoltymn,pow1)
len2 = sqrt(0.5*(len-1))*len1
kvmn = pow(len2/(len2+1),sqrt(pow2mn))

if del1mn > 0 then
bsmaxmn = minusDM
else
bsmaxmn = minusDM - kvmn*del1mn
endif

if del2mn < 0 then
bsminmn = minusDM
else
bsminmn = minusDM - kvmn*del2mn
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)
alphamn = pow(beta,pow2mn)

Filt0mn = (1 - alphamn) * minusDM + alphamn * Filt0mn[1]
Det0mn = (minusDM - Filt0mn[0]) * (1 - beta) + beta * Det0mn[1]
Filt1mn = Filt0mn[0] + phaseratio * Det0mn[0]
Det1mn = (Filt1mn[0] - jurikMinus[1]) * ((1 - alphamn) * (1 - alphamn)) + (alphamn * alphamn) * Det1mn[1]
jurikMinus = jurikMinus[1] + Det1mn[0]
ENDIF

minus = 100*jurikMinus/trur

/////////////////////////////////////////////////////////////
////////Trigger
trigger = plus-minus
///////////////////////////////////////////////////////////
///////signal
siglen = MAX(siglen, 1)
len1 = max(log(sqrt(0.5*(siglen-1)))/log(2)+2,0)
Pow1 = max(len1-2,0.5)
avglen = 65
IF BarIndex < avglen+1 THEN
Filt0 = 0
Filt1 = 0
signal = 0
bsmax = 0
bsmin = 0
vsum = 0
avolty = 0
ELSE
del1 = trigger-bsmax[1]
del2 = trigger-bsmin[1]
div = 1/(10+10*(min(max(siglen-10,0),100))/100)
if abs(del1)>abs(del2) then
volty = abs(del1)
else
volty = abs(del2)
endif
vsum = vsum[1]+div*(volty-volty[10])

tempavg = average[avglen](vsum)

y= barindex+1
if (y <= avglen+1) then
avolty = avolty[1]+2*(vsum-avolty[1])/(avglen+1)
else
avolty = tempavg
endif

if avolty > 0 then
dvolty = volty/avolty
else
dvolty = 0
endif

if dvolty > pow(len1,1/pow1) then
dvolty = pow(len1,1/pow1)
else
dvolty = dvolty
endif

if dvolty < 1 then
dvolty= 1
else
dvolty = dvolty
endif

pow2 = pow(dvolty,pow1)
len2 = sqrt(0.5*(siglen-1))*len1
kv = pow(len2/(len2+1),sqrt(pow2))

if del1 > 0 then
bsmax = trigger
else
bsmax = trigger - kv*del1
endif

if del2 < 0 then
bsmin = trigger
else
bsmin = trigger - kv*del2
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 * (siglen - 1) / (0.45 * (siglen - 1) + 2)
alpha = pow(beta,pow2)

Filt0 = (1 - alpha) * trigger + alpha * Filt0[1]
Det0 = (trigger - Filt0[0]) * (1 - beta) + beta * Det0[1]
Filt1 = Filt0[0] + phaseratio * Det0[0]
Det1 = (Filt1[0] - signal[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1]
signal = signal[1] + Det1[0]
ENDIF
/////////////////////////////////////////////////////
/////color
if trigger >=0 and trigger>=signal then
r=0
g=120
elsif trigger >=0 and trigger<signal then
r=0
g=255
elsif trigger <0 and trigger<signal then
r=120
g=0
else
r=255
g=0
endif

return trigger as "Histo DMX"coloured(r,g,0)style(histogram),trigger as "DMX" style(line), signal as "Signal"coloured("white")style(line,2)

Ξ3 thanked this post

PRC_Jurik-DMX-Histogram.itf

03/14/2024 at 7:12 AM #229742 quote

Ξ3

Participant

Average

Much appreciated!

Author

Posts

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

You must be logged in to reply to this topic.

Conversion of Jurik DMX Histogram Indicator from Trading View

ProBuilder: Indicators & Custom Tools

New Reply

Author

Ξ3 @cbeukes Participant

Summary

This topic contains 2 replies,
has 2 voices, and was last updated by Ξ3
1 year, 12 months ago.

Topic Details

Forum:	ProBuilder: Indicators & Custom Tools
Language:	English
Started:	01/17/2024
Status:	Active
Attachments:	2 files

Expert Services

No recent search

Conversion of Jurik DMX Histogram Indicator from Trading View

Conversion of Jurik DMX Histogram Indicator from Trading View ProBuilder: Indicators & Custom Tools

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

Conversion of Jurik DMX Histogram Indicator from Trading View

ProBuilder: Indicators & Custom Tools