Conversion of Jurik DMX Histogram Indicator from Trading View

This topic has 2 replies, 2 voices, and was last updated 1 month ago by Ξ3.

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

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

Ξ3

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)

Ξ3

Participant

Topics: 12

Replies: 26

Been thanked: 3 times

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

Iván

Hi,
Here it’s the code:

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

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

1 user thanked author for this post.

Ξ3

Iván

Moderator

Topics: 0

Replies: 306

Been thanked: 83 times

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

Ξ3

Much appreciated!

Ξ3

Participant

Topics: 12

Replies: 26

Been thanked: 3 times

Author

Posts

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

Find exclusive trading pro-tools on