name
stringlengths 1
64
| url
stringlengths 44
135
| author
stringlengths 3
30
| author_url
stringlengths 34
61
| likes_count
int64 0
33.2k
| kind
stringclasses 3
values | pine_version
int64 1
5
| license
stringclasses 3
values | source
stringlengths 177
279k
|
|---|---|---|---|---|---|---|---|---|
Buying/Selling Pressure Cycle (PreCy) | https://www.tradingview.com/script/T7zFa1gR-Buying-Selling-Pressure-Cycle-PreCy/ | ALifeToMake | https://www.tradingview.com/u/ALifeToMake/ | 47 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ALifeToMake
//@version=5
indicator(title="Buying/Selling Pressure Cycle (PreCy) V6.8", shorttitle="PreCy", overlay=false, precision=0)
// INPUTS --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
showSignal = input.bool(true, title = "The SIGNAL line", group="Display")
signalVisibility = showSignal == true ? 0 : 100
showSignalPivots = input.bool(true, title = "The pivot lines of the SIGNAL", group="Display")
signalPivotsVisibility = showSignalPivots == true ? 70 : 100
showCycle = input.bool(true, title = "The CYCLE areas", group="Display")
cycleVisibility = showCycle == true ? 0 : 100
cycleBGVisibility = showCycle == true ? 25 : 100
UPchecked = input.bool(true, title = "UP", group="Alerts", tooltip ="Show alerts of bullish nature.")
DOWNchecked = input.bool(true, title = "DOWN", group="Alerts", tooltip ="Show alerts of bearish nature.")
EXCELLchecked = input.bool(true, title = "Excellent signals", group="Alerts", tooltip ="Triggered when the SIGNAL and the CYCLE go in the same direction, and the CYCLE crosses 50 or -50, in a relatively active market.")
GOODchecked = input.bool(true, title = "Good signals", group="Alerts", tooltip ="Triggered after 3 consecutive SIGNALS above 0 or under 0, in a relatively active market.")
Increased3checked = input.bool(true, title = "3 increases of pressure", group="Alerts", tooltip ="Early sign detection. Triggered after 3 consecutive SIGNAL increases of pressure, in a relatively active market.")
Increased2checked = input.bool(true, title = "2 increases of pressure", group="Alerts", tooltip ="Early sign detection. Triggered after 3 consecutive SIGNALS above or below 0 with an increase of pressure between the 1st and the 3rd, in a relatively active market.")
SignalLength = input.int(1, minval = 1, title = "Smoothing length", group="SIGNAL (Goes from 100 to -100)")
SignalMAbullColor=input.color(#22ab94, title="Increase of buying pressure", tooltip = "Highlights the buying pressure of the SIGNAL (% of buying pressure - % of selling pressure).", group="SIGNAL (Goes from 100 to -100)")
SignalMAbullDecColor=input.color(#22ab94, title="Buying pressure slowing down", group="SIGNAL (Goes from 100 to -100)")
SignalMAMixColor=input.color(#787b86, title="When pressures are equal", group="SIGNAL (Goes from 100 to -100)")
SignalMAbearColor=input.color(color.new(#f7525f, 0), title="Increase of selling pressure", tooltip = "Highlights the selling pressure of the SIGNAL (% of buying pressure - % of selling pressure).", group="SIGNAL (Goes from 100 to -100)")
SignalMAbearDecColor=input.color(color.new(#f7525f, 0), title="Selling pressure slowing down", group="SIGNAL (Goes from 100 to -100)")
cycleLength = input.int(6, minval = 1, title = "Length", group="CYCLE (Goes from 200 to -200)", tooltip = "Moving Average of the SIGNAL * (body of this candle / 200 period Moving Average of the candle's bodies)")
cycleTrigger = input.int(40, minval = 1, title = "Trigger alert distance from zero line", group="CYCLE (Goes from 200 to -200)", tooltip = "Used to estimate the activity of the market. 1 of the last 3 candles has to be above this value (or below negative this value) for the alerts to trigger.")
increaseColor=input.color(#ce93d8, title="Increase of pressure", group="Cycle (from 200 to -200)")
decreaseColor=input.color(#d1c4e9, title="Decrease of pressure", group="Cycle (from 200 to -200)")
levelOne = input.float(120, title = "Top level", group="Cycle (from 200 to -200)", tooltip = "Where the gradient stops increasing.")
levelTwo = input.float(-120, title = "Bottom level", group="Cycle (from 200 to -200)", tooltip = "Where the gradient stops increasing.")
increaseBGColor=input.color(#d1c4e9, title="Increase of pressure's background", group="Cycle (from 200 to -200)")
decreaseBGColor=input.color(#c5b7df, title="Decrease of pressure's background", group="Cycle (from 200 to -200)")
halfBGColor=input.color(#cdbee6, title="Crossing zeroline background", group="Cycle (from 200 to -200)")
lowZoneBGColor=input.color(color.new(#d1d4dc, 0), title="Low intensity zone's background")
topLine =input.color(color.new(#70ccbd, 0), title="100% line")
botLine =input.color(color.new(#faa1a4, 0), title="-100% line")
zeroLineColor=input.color(#9598a1, title="Zeroline")
// CANDLE calculations ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
topwick = open<close ? high - close : high - open
bottomwick = open<close ? open-low : close-low
body = open<close ? close-open : open-close
fractionup = open<close ? (topwick + bottomwick + 2*body)/(2*topwick + 2*bottomwick + 2*body) : (topwick + bottomwick)/(2*topwick + 2*bottomwick + 2*body)
fractiondown = open<close ? (topwick + bottomwick)/(2*topwick + 2*bottomwick + 2*body) : (topwick + bottomwick + 2*body)/(2*topwick + 2*bottomwick + 2*body)
// Percentages -----------------------------------------------------------------------------------------
totalOfFractions = fractionup + fractiondown
percentUp=(100*fractionup)/totalOfFractions
percentDown=(100*fractiondown)/totalOfFractions
// PRECY Calculations --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
float bodyMA = ta.sma(body, 200)
velocityRatio = body/bodyMA
velocityRatioApply = velocityRatio > 1 ? velocityRatio : 1
Signal = percentUp-percentDown
SignalMA = ta.sma(Signal,SignalLength)
pressureCycle = (Signal*velocityRatioApply)
preCycleMA = ta.sma(pressureCycle,cycleLength)
// CYCLE LIMITER (+-200) -------------------------------------------------------------------------------
float pressureCycleOverTopRatio = 0.0
float pressureCycleExcess = 0.0
preCycleMAlimited=preCycleMA
if preCycleMA>100
pressureCycleExcess:=(preCycleMA-100)
pressureCycleOverTopRatio:=(pressureCycleExcess/100)+1
preCycleMAlimited:=100+(pressureCycleExcess/pressureCycleOverTopRatio)
else if preCycleMA<-100
pressureCycleExcess:=(math.abs(preCycleMA)-100)
pressureCycleOverTopRatio:=(pressureCycleExcess/100)+1
preCycleMAlimited:=(-pressureCycleExcess/pressureCycleOverTopRatio)-100
// PLOTS ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Horizontal scale lines-------------------------------------------------------------------------------
plot(150, "+150 line", color=color.new(#003a7c, 100), linewidth=1, style=plot.style_line)
plot(100, "+100 line", color=topLine, linewidth=1, style=plot.style_circles)
plusTWline=plot(50, "+50 line", color=color.new(#002c5e, 100), linewidth=1)
zeroline=plot(0, "Zeroline", color=zeroLineColor, linewidth=1)
minusTWline=plot(-50, "-50 line", color=color.new(#42000a, 100), linewidth=1)
plot(-100, "-100 line", color=botLine, linewidth=1, style=plot.style_circles)
plot(-150, "-150 line", color=color.new(#58000d, 100), linewidth=1, style=plot.style_line)
// SIGNAL COLORS ---------------------------------------------------------------------------------------
SignalMAcolor =SignalMA[1] > 0 and SignalMA > 0 and SignalMA >= SignalMA[1] ? SignalMAbullColor : SignalMA[1] > 0 and SignalMA > 0 and SignalMA < SignalMA[1] ? SignalMAbullDecColor : SignalMA[1] < 0 and SignalMA < 0 and SignalMA <= SignalMA[1] ? SignalMAbearColor : SignalMA[1] < 0 and SignalMA < 0 and SignalMA > SignalMA[1] ? SignalMAbearDecColor : SignalMA[1] >= 0 and SignalMA <= 0 and SignalMA > -50 and math.abs(SignalMA[1]) < math.abs(SignalMA) ? SignalMAbearColor : SignalMA[1] >= 0 and SignalMA <= 0 and SignalMA > -50 and math.abs(SignalMA[1]) > math.abs(SignalMA) ? SignalMAbullDecColor : SignalMA[1] >= 0 and SignalMA <= -50 ? SignalMAbearColor : SignalMA[1] <= 0 and SignalMA >= 0 and SignalMA < 50 and math.abs(SignalMA) < math.abs(SignalMA[1]) ? SignalMAbearDecColor : SignalMA[1] <= 0 and SignalMA >= 0 and SignalMA < 50 and math.abs(SignalMA) > math.abs(SignalMA[1]) ? SignalMAbullColor : SignalMA[1] <= 0 and SignalMA >= 50 ? SignalMAbullColor : SignalMAMixColor
// CYCLE COLORS ----------------------------------------------------------------------------------------
// Color generator
gradientGen(signal) =>
returnedColor= signal>=0 ? color.from_gradient(signal, 0, levelOne, decreaseColor, increaseColor) : signal<0 ? color.from_gradient(signal, levelTwo, 0, increaseColor, decreaseColor) : #FFFFFF
pressureCycleBGColor=preCycleMA > 0 and preCycleMA[1] < 0 ? halfBGColor : preCycleMA < 0 and preCycleMA[1] > 0 ? halfBGColor : preCycleMA > 0 and preCycleMA > preCycleMA[1] ? increaseBGColor : preCycleMA > 0 and preCycleMA < preCycleMA[1] ? decreaseBGColor : preCycleMA < 0 and preCycleMA < preCycleMA[1] ? increaseBGColor : preCycleMA < 0 and preCycleMA > preCycleMA[1] ? decreaseBGColor : decreaseBGColor
// PLOTTING & FILLING the Signal and the Cycle ---------------------------------------------------------
fill(plusTWline, minusTWline, color=lowZoneBGColor)
cycleLine=plot(preCycleMAlimited, color=color.new(gradientGen(preCycleMAlimited), cycleVisibility), linewidth=2, style=plot.style_line)
plot(SignalMA, color=color.new(SignalMAcolor, signalVisibility), linewidth=2, style=plot.style_line)
fill(zeroline, cycleLine, color=color.new(pressureCycleBGColor, cycleBGVisibility))
// PIVOTS --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
leftHighBars = input(1, title="High left look back", group="Pivot lines")
rightHighBars = input(1, title="High right look back", group="Pivot lines")
highBarsColor=input.color(#828282, title="High", group="Pivot lines")
plHigh = ta.pivothigh(SignalMA, leftHighBars, rightHighBars)
plot(plHigh, style=plot.style_line, linewidth=1, color=color.new(highBarsColor, signalPivotsVisibility), offset=-rightHighBars)
leftLowBars = input(1, title="Low left look back", group="Pivot lines")
rightLowBars = input(1, title="Low right look back", group="Pivot lines")
lowBarsColor=input.color(#828282, title="Low", group="Pivot lines")
plLow = ta.pivotlow(SignalMA, leftLowBars, rightLowBars)
plot(plLow, style=plot.style_line, linewidth=1, color=color.new(lowBarsColor, signalPivotsVisibility), offset=-rightLowBars)
// ALERTS -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// AMPLITUDES Calculations -----------------------------------------------------------------------------
amp = (high - low)/((high+low)/2)
float ampMA = ta.sma(amp, 250)
ampGlobal = amp > ampMA
ampLocal = preCycleMA > cycleTrigger or preCycleMA < -cycleTrigger or preCycleMA[1] > cycleTrigger or preCycleMA[1] < -cycleTrigger or preCycleMA[2] > cycleTrigger or preCycleMA[2] < -cycleTrigger
// Conditions ------------------------------------------------------------------------------------------
crossOverCurrPos = ta.crossover(preCycleMAlimited,50) and preCycleMAlimited[1]<0
crossOverCurrNeg = ta.crossover(preCycleMAlimited,-50) and preCycleMAlimited[1]<-50
crossOverOnePos = ta.crossover(preCycleMAlimited[1],50) and preCycleMAlimited[2]<0
crossOverOneNeg = ta.crossover(preCycleMAlimited[1],-50) and preCycleMAlimited[2]<-50
crossUnderCurrPos = ta.crossunder(preCycleMAlimited,50) and preCycleMAlimited[1]>50
crossUnderCurrNeg = ta.crossunder(preCycleMAlimited,-50) and preCycleMAlimited[1]<0
crossUnderOnePos = ta.crossunder(preCycleMAlimited[1],50) and preCycleMAlimited[2]>50
crossUnderOneNeg = ta.crossunder(preCycleMAlimited[1],-50) and preCycleMAlimited[2]<0
excellentUp = false
goodUp = false
increase3Up = false
increase2Up = false
excellentDown = false
goodDown = false
increase3Down = false
increase2Down = false
// UP -----------------------------------------------
if UPchecked and ampGlobal and ampLocal and Signal > 0 and barstate.isconfirmed
excellentUp := EXCELLchecked and crossOverCurrPos or crossOverCurrNeg or crossOverOnePos or crossOverOneNeg
goodUp := GOODchecked and Signal[1] > 0 and Signal[2] > 0
increase3Up := Increased3checked and Signal > Signal[1] and Signal[1] > Signal[2] and Signal[2] > Signal[3]
increase2Up := Increased2checked and Signal >= 0 and Signal[1] >= 0 and Signal[2] >= 0 and Signal > Signal[2]
// DOWN ---------------------------------------------
if DOWNchecked and ampGlobal and ampLocal and Signal < 0 and barstate.isconfirmed
excellentDown := EXCELLchecked and crossUnderCurrPos or crossUnderCurrNeg or crossUnderOnePos or crossUnderOneNeg
goodDown := GOODchecked and Signal[1] < 0 and Signal[2] < 0
increase3Down := Increased3checked and Signal[3] > Signal[2] and Signal[2] > Signal[1] and Signal[1] > Signal
increase2Down := Increased2checked and Signal <= 0 and Signal[1] <= 0 and Signal[2] <= 0 and Signal[2] > Signal
// TRIGGERS and messages -------------------------------------------------------------------------------
if excellentUp
alert('Excellent ▲ signals on TF:'+timeframe.period)
else if excellentDown
alert('Excellent ▼ signals on TF:'+timeframe.period)
else if goodUp
alert('Good ▲ signals on TF:'+timeframe.period)
else if goodDown
alert('Good ▼ signals on TF:'+timeframe.period)
else if increase3Up
alert('3 increases of bullish pressure on TF:'+timeframe.period)
else if increase3Down
alert('3 increases of bearish pressure on TF:'+timeframe.period)
else if increase2Up
alert('2 increases of bullish pressure on TF:'+timeframe.period)
else if increase2Down
alert('2 increases of bearish pressure on TF:'+timeframe.period) |
shadow bar | https://www.tradingview.com/script/UIaGPd8Y-shadow-bar/ | ceshead | https://www.tradingview.com/u/ceshead/ | 26 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ceshead
//This indicator shows a new candle bar formation looking back a period (n) of time.
//In this way the trader can see how the traditional bars are part of a larger formation that can show a trend or a range.
//The new shadow bars are drawn with a degree of transparency that makes it possible to distinguish traditional candlesticks;
//and where shadow candles can be seen as support or resistance to traditional candlesticks.
//When the traditional candlesticks are the same size as the shadow candlesticks, it can be expected that we are forming a compression or range that will result in a strong move.
//In addition to the shadow bars, there is a ribbon created from the new candlestick data that is formed as a line from the linear regression function and another that is the previous line smoothed by its exponential moving average.
//This ribbon allows you to see the trend more clearly and at the crossings of the lines that form the possible reversals or continuations of the trend.
//The indicator has the timeframe field active, which allows the indicator to be displayed in other temporalities.
//@version=5
indicator("shadow bar","shadow bar",format =format.price,overlay=true, timeframe = "", precision = 5)
//inputs
n=input(60,"bars back", group="shadow bars")
tryforce=input(false,title = "Automatic selection of bars back", group="shadow bars")
mins=timeframe.multiplier
if(tryforce)
if(timeframe.period == "D")
n:=30
else if(timeframe.period == "W")
n:=52
else if(timeframe.period == "M")
n:=12
else if(timeframe.multiplier<15)
n:=n
else if(timeframe.multiplier>=15 and timeframe.multiplier<1440)
n:=10080/mins
//counter
var counter=0
if(counter==n)
counter:=0
counter:=counter+1
//close counter
//Ombligo
ombligo=open>close?(open-close)/2+close:(close-open)/2+open
//inputs
formationTypeInput = input.string("f1", title="bar formation type", options=["f1", "f2", "f3", "f4"], group="shadow bars")
displayBars=input(true,"show shadow bars", group = "shadow bars")?display.all - display.status_line:display.none
displayWick=input(true,"show wicks", group = "shadow bars")
longColor=input.color(#089981,"green bar", group = "shadow bars")
shortColor=input.color(#f23645,"red bar", group = "shadow bars")
t=input(75,"Bars transparency", group="shadow bars")
oc2=input(false,"Show ribbon", group="shadow ribbon")
ep=input(60,"ribbon period", group="shadow ribbon")
greenColor=input.color(color.green,"green band", group = "shadow ribbon")
redColor=input.color(color.red,"red band", group = "shadow ribbon")
c=input(35,"Band transparency", group="shadow ribbon")
extreme_band=input(true, title="extreme lines",group= "Only for f1 type formation - goldenRatio lines")
goldenRatioband=input(true, group= "Only for f1 type formation - goldenRatio lines", title="Show golden ratio lines")
//bar formation
formation(type) =>
switch type
"f1" =>
formLow=ta.lowest(low,n)
formHigh=ta.highest(high,n)
[formLow, formHigh]
"f2" =>
formLow=(low[n]+low)/2
formHigh=(high[n]+high)/2
[formLow, formHigh]
"f3" =>
formLow=low[n]
formHigh=high[n]
[formLow, formHigh]
"f4" =>
formLow=ta.linreg(low,n,1)
formHigh=ta.linreg(high,n,1)
[formLow, formHigh]
//Candels
newOpen=open[n]
[newLow, newHigh]=formation(formationTypeInput)
newLow:=newOpen<newLow?newOpen:newLow
newHigh:=newOpen>newHigh?newOpen:newHigh
newCLose=close
//Tapes and bands
tape=math.avg(newOpen,newCLose,newHigh,newLow)
tape:=ta.linreg(tape,ep,4)
ema=ta.ema(tape,8)
changeColor=tape<ema?color.new(redColor,c):color.new(greenColor,c)
delta=newHigh-newLow
mediaExtrema=(newHigh+newLow)/2
goldenRup=delta*0.618+newLow //0.618 ó 1-0.368 ó (0.618+(1-0.368))/2
goldenRdn=delta*(1-0.618)+newLow //1-0.618 ó 0.368 ó ((1-0.618)+0.368)/2
goldenExtup=delta*0.786+newLow//newHigh+delta*((1-0.618)+0.368)/2
goldenExtdn=delta*(1-0.786)+newLow//-delta*((1-0.618)+0.368)/2
//Plots
positiveCross=(ta.crossover(ombligo,goldenRdn) and close<mediaExtrema) or (ta.crossover(ombligo,goldenRup) and ombligo>open[1] and high>high[1]) or (low>goldenRup) or (ombligo>mediaExtrema)
negativeCross=(ta.crossunder(ombligo,goldenRup) and close>mediaExtrema) or (ta.crossunder(ombligo,goldenRdn) and ombligo<open[1] and low<low[1]) or (high<goldenRdn) or (ombligo<mediaExtrema)
candelcolor=newCLose>newOpen and ombligo>mediaExtrema?longColor:shortColor
candelcolor:=color.new(candelcolor,t)
show_extremeLine=extreme_band and (formationTypeInput=="f1")
displayExtreme=show_extremeLine?display.all - display.status_line:display.none
displayGolden=goldenRatioband and (formationTypeInput=="f1")?display.all - display.status_line:display.none
plotcandle(newOpen,newHigh,newLow,newCLose,"shadow bars", candelcolor,color.new(candelcolor,displayWick?t:100), bordercolor = candelcolor, display = displayBars)
plotema=plot(oc2?tape:na, color=changeColor, linewidth = 2, display = display.all - display.status_line)
plotema2=plot(oc2?ema:na, color=changeColor, display = display.all - display.status_line)
fill(plotema,plotema2,color = changeColor)
plot(newHigh,color=color.gray, display = displayExtreme, linewidth = 2)
plot(newLow, color=color.gray, display = displayExtreme, linewidth = 2)
plot(goldenExtup, display = displayGolden, color=color.purple, display = display.all - display.status_line)
plot(goldenExtdn, display = displayGolden, color=color.purple, display = display.all - display.status_line)
plot(mediaExtrema, color=color.aqua, display = displayGolden, display = display.all - display.status_line)
plot(goldenRup, color=color.orange, display = displayGolden)
plot(goldenRdn, color=color.orange, display = displayGolden)
//end |
RSI, SRSI, MACD and DMI cross - Open source code | https://www.tradingview.com/script/XvbAWq6O-RSI-SRSI-MACD-and-DMI-cross-Open-source-code/ | Trading_Paradise | https://www.tradingview.com/u/Trading_Paradise/ | 181 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Trading_Paradise
//@version=5
indicator("RSI, SRSI, MACD and DMI cross", overlay=true)
// Input
rsiLength = input.int(title="RSI Length", defval=14, minval=1)
smoothK = input.int(title="Smooth K", defval=3, minval=1)
stochLength = input.int(title="Stochastic Length", defval=14, minval=1)
atr = ta.atr(14)
// RSI
rsiOB = ta.rsi(close, rsiLength)
// Stoch RSI
stochRsi = ta.stoch(source=rsiOB, high=rsiOB, low=rsiOB, length=stochLength)
stochK = ta.sma(stochRsi, smoothK)
stochD = ta.sma(stochK, smoothK)
// Signals
rsiBuy1 = rsiOB <= 35 and stochK <= 15
rsiBuy2 = rsiOB <= 28 and stochK <= 15 or rsiOB <= 25 and stochK <= 10 or rsiOB <= 28
rsiSell1 = rsiOB >= 75 and stochK >= 85
rsiSell2 = rsiOB >= 80 and stochK >= 85 or rsiOB >= 85 and stochK >= 90 or rsiOB >= 82
// Buy Signals
plotshape(rsiBuy1, title="Good Buy", style=shape.triangleup, location=location.belowbar, color=color.green, size=size.tiny)
plotshape(rsiBuy2, title="Incredible Buy", style=shape.labelup, location=location.belowbar, color=color.rgb(149, 137, 48), size=size.small)
// Sell Signals
plotshape(rsiSell1, title="Good Sell", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.tiny)
plotshape(rsiSell2, title="Incredible Sell", style=shape.labeldown, location=location.abovebar, color=color.rgb(186, 105, 155), size=size.small)
// Special Signals
crossup = ta.crossover(stochK, stochD) and stochK[1] <= 20
crossdown = ta.crossunder(stochK, stochD) and stochK[1] >= 80
plotshape(crossup, title="Stoch crossup", style=shape.circle, location=location.belowbar, color=color.rgb(227, 209, 209), size=size.tiny)
plotshape(crossdown, title="Stoch crossdown", style=shape.circle, location=location.abovebar, color=color.rgb(82, 77, 77), size=size.tiny)
// MACD inputs
fastLength = input.int(12, "Fast Length")
slowLength = input.int(26, "Slow Length")
signalLength = input.int(9, "Signal Length")
// MACD calculations
[macdLine, _, histLine] = ta.macd(close, fastLength, slowLength, signalLength)
// MACD Long signal
longSignal = macdLine < 0 and ta.change(histLine > 0 ? 1 : 0) == 1 and macdLine[1] < 0 and histLine[1] < 0
// MACD Short signal
shortSignal = macdLine > 0 and ta.change(histLine < 0 ? 1 : 0) == 1 and macdLine[1] > 0 and histLine[1] > 0
// Macd Plot signals
plotshape(longSignal ? low : na, title = "Macdcrossup", text="M↑", textcolor=color.blue, style = shape.flag)
plotshape(shortSignal ? high : na, title = "Macdcrossdown", text="M↓", textcolor=color.blue, style = shape.flag)
// DMI inputs
dmiLen = input(14, title="DMI Length")
adxSmoothing = input(14, title="ADX Smoothing")
// Calculate DMIs
[minusDI, plusDI, adx] = ta.dmi(dmiLen, adxSmoothing)
// Bullish signal
bullishSignal = ta.cross(minusDI, plusDI) and minusDI > plusDI
// Bearish signal
bearishSignal = ta.cross(plusDI, minusDI) and plusDI > minusDI
// Plot signals
plotshape(bullishSignal,title="DMI crossup", location=location.belowbar, style = shape.diamond, text="D+", textcolor=color.rgb(227, 209, 209), color=color.rgb(227, 209, 209), size=size.tiny)
plotshape(bearishSignal, title="DMI crossdown", location=location.abovebar, style = shape.diamond, text="D-",textcolor=color.rgb(82, 77, 77), color=color.rgb(82, 77, 77), size=size.tiny)
// RSI buy and sell alerts
rsiBuyAlert = rsiBuy1 or rsiBuy2
rsiSellAlert = rsiSell1 or rsiSell2
alertcondition(rsiBuy1, title="Good Buy ", message="Good moment to buy")
alertcondition(rsiBuy2, title="Incredible Buy", message="Incredible moment to buy")
alertcondition(rsiSell1, title="Good Sell", message="Good moment to sell")
alertcondition(rsiSell2, title="Incredible Sell", message="Incredible moment to to sell")
// Stochastic RSI cross alerts
crossUpAlert = crossup
crossDownAlert = crossdown
alertcondition(crossUpAlert, title="Stochastic RSI Cross Up", message="Stochastic RSI Cross Up")
alertcondition(crossDownAlert, title="Stochastic RSI Cross Down", message="Stochastic RSI Cross Down")
// MACD cross alerts
longSignalAlert = longSignal
shortSignalAlert = shortSignal
alertcondition(longSignalAlert, title="MACD Long Signal", message="MACD Long Signal")
alertcondition(shortSignalAlert, title="MACD Short Signal", message="MACD Short Signal")
// DMI cross alerts
bullishSignalAlert = bullishSignal
bearishSignalAlert = bearishSignal
alertcondition(bullishSignalAlert, title="DMI Bullish Signal", message="DMI Bullish Signal")
alertcondition(bearishSignalAlert, title="DMI Bearish Signal", message="DMI Bearish Signal")
|
High Volume Candles Detector - Open Source Code | https://www.tradingview.com/script/yetSDA8G-High-Volume-Candles-Detector-Open-Source-Code/ | Trading_Paradise | https://www.tradingview.com/u/Trading_Paradise/ | 218 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Trading_Paradise
//@version=5
indicator(title="High Volume Candles", overlay = true)
// Previously existing inputs
lengthMA = input(20, group= "Define Volume Inputs", title="Length of MA for Volume")
lengthHighest = input(14, group= "Define Volume Inputs", title="Lookback Period for Highest Volume")
multiplier = input(2.0, group= "Define Volume Inputs", title="Volume Multiplier")
bullishOnly = input(false, group= "Define Volume Inputs", title="Plot Green Candles Only")
bearishOnly = input(false, group= "Define Volume Inputs", title="Plot Red Candles Only")
// New inputs
smaSelected = input(false, group = "Filter candles based on a MA", title="Use SMA for Price")
emaSelected = input(true, group = "Filter candles based on a MA", title="Use EMA for Price")
lengthPriceMA = input(21, group = "Filter candles based on a MA", title="Length of MA for Price")
filterFullCandleBelow = input(false, group = "Filter candles based on a MA", title="Filter Full Candle Below MA")
filterFullCandleAbove = input(false, group = "Filter candles based on a MA", title="Filter Full Candle Above MA")
// Calculate price moving average based on selected MA type
var float priceMA = na
if smaSelected
priceMA := ta.sma(close, lengthPriceMA)
else if emaSelected
priceMA := ta.ema(close, lengthPriceMA)
smaVolume = ta.sma(volume, lengthMA)
highVolume = ta.change(volume) > multiplier * smaVolume
highestVolume = ta.highest(volume, lengthHighest)
isHighestInPeriod = volume == highestVolume
isBullish = close > open
isBearish = open > close
var bool filterBullBear = na
if bullishOnly
filterBullBear := isBullish
else if bearishOnly
filterBullBear := isBearish
else
filterBullBear := true
// Filter for full candle body above/below moving average
var bool filterFullCandle = na
if filterFullCandleBelow
filterFullCandle := high < priceMA
else if filterFullCandleAbove
filterFullCandle := low > priceMA
else
filterFullCandle := true
highVolumeAndHighestInPeriod = highVolume and isHighestInPeriod and filterBullBear and filterFullCandle
plotshape(series=highVolumeAndHighestInPeriod and isBullish, title="High Volume Green Candle", location=location.belowbar, color=color.green, style=shape.circle, size=size.tiny)
plotshape(series=highVolumeAndHighestInPeriod and isBearish, title="High Volume Red Candle", location=location.abovebar, color=color.red, style=shape.circle, size=size.tiny)
plot(priceMA, color=color.blue, title="Moving Average")
alertcondition(highVolumeAndHighestInPeriod and isBullish, title="High Volume Green Candle Alert", message="High volume green candle detected!")
alertcondition(highVolumeAndHighestInPeriod and isBearish, title="High Volume Red Candle Alert", message="High volume red candle detected!")
|
Variance Windows | https://www.tradingview.com/script/G6s6hEPJ-Variance-Windows/ | pkchari | https://www.tradingview.com/u/pkchari/ | 10 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © pkchari
//@version=5
indicator("Variance windows", overlay=true)
span1 = input(20, title="ShortTerm Analysis span", tooltip="Period for short-term variance estimation")
span2 = input(50, title="LongTerm Analysis span", tooltip="Period for Long-term variance estimation")
emaSize = input(55, title = "ZLEMA Size", tooltip = "Length of Zero-lag EMA used as the centerline")
errorBar = input(2.0, "Num Std Deviations", tooltip="How many standard deviations wide should the windows be")
// NOTE : for Error Bars, you can essentially treat it like a normal distribution z-score
// +/- 1 sigma = 68% chance that price will stay within this range
// +/- 2 sigma = 95% chance ...
// +/- 3 sigma = 99.7% chance ...
// For fractional standard deviations, you can do things like
// +/- 0.5 sigma = 38.3% chance of price staying within these windows
// +/- 1.5 sigma = 86.6% chance of staying of in the windowed range
// +/- 1.644444 sigma = 90% chance
// +/- 1.15 sigma = 75% chance
// +/- 0.675 sigma = 50% chance
// Yeah, I know, SMA is more pedantically correct for this computation of variance,
// but using EMA is giving some slightly better results in terms of readability of the chart.
sma1 = ta.ema(close, span1) * ta.ema(close, span1)
sma2 = ta.ema(close * close, span1)
shortSigma = math.sqrt(sma2 - sma1)
sma1b = ta.ema(close, span2) * ta.ema(close, span2)
sma2b = ta.ema(close * close, span2)
longSigma = math.sqrt(sma2b - sma1b)
emaData = close + (close - close[(emaSize - 1)*0.5])
followCurve = ta.ema(emaData, emaSize)
plot(followCurve + errorBar*shortSigma, title="+2Sigma(short)", color=color.green, linewidth=1, editable=true)
plot(followCurve - errorBar*shortSigma, title="-2Sigma(short)", color=color.blue, linewidth=1, editable=true)
plot(followCurve + errorBar*longSigma, title="+2Sigma(long)", color=color.teal, linewidth=2, editable=true)
plot(followCurve - errorBar*longSigma, title="-2Sigma(long)", color=color.purple, linewidth=2, editable=true)
// Another option -- plot variances (standard deviation, really) as percentages (in this case, turn overlay=false)
// plot(100 * errorBar * shortSigma / math.sqrt(sma1), title="Short Term Sigma", color=color.green, linewidth=1, editable=true)
// plot(100 * errorBar * longSigma / math.sqrt(sma1b), title="Long Term Sigma", color=color.blue, linewidth=2, editable=true)
|
True Trend Oscillator [wbburgin] | https://www.tradingview.com/script/R3T9epUR-True-Trend-Oscillator-wbburgin/ | wbburgin | https://www.tradingview.com/u/wbburgin/ | 514 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © wbburgin
//@version=5
indicator("True Trend Oscillator [wbburgin]",overlay=false)
import jdehorty/KernelFunctions/2 as k
threshold = input.int(20,"Range Threshold",minval=0,maxval=100,
tooltip="Stochastic threshold (0-100) to identify ranging markets. A higher threshold will identify more ranges but will be slower at catching the trend.",
group="General")
l = input.int(14,"ATR Length",group="Stoch ATR")
lengthStoch = input.int(14, "Stochastic Length", minval=1,group="Stoch ATR")
lb = input.int(25,"Lookback",group="Stoch ATR",tooltip="The number of bars used for the estimation of the rational quadratic kernel.")
rw = input.int(1,"Relative Weighting",group="Stoch ATR")
smoothK = input.int(3, "Stochastic Smoothing", minval=1,group="Stoch ATR")
rsisrc = input.source(close,"RSI Source",group="RSI")
rsilen = input.int(14,"RSI Length",group="RSI")
stochatr(atr,smoothK,lookback,weighting,lengthStoch)=>
y = k.rationalQuadratic(ta.stoch(atr,atr,atr,lengthStoch),lookback,weighting,smoothK)
y
atr = ta.atr(l)
k = stochatr(atr,smoothK,lb,rw,lengthStoch)
rsi = ta.rsi(rsisrc,rsilen)
bull = math.sqrt(rsi * k)
bear = math.sqrt((100 - rsi) * k)
barcolor(bull > bear and math.min(bull,bear) > threshold ? color.lime : bear > bull and math.min(bull,bear) > threshold ? color.red : color.gray)
plot(bull, color= color.lime, title="Bull Trend")
plot(bear, color= color.red, title= "Bear Trend")
top = hline(80)
bottom = hline(threshold,linestyle=hline.style_solid,color=color.green)
base = hline(0,linestyle=hline.style_solid,color=color.red)
fill(top,bottom,color=color.new(color.blue,90))
fill(bottom,base,color=color.new(color.red,90)) |
MultiMoves | https://www.tradingview.com/script/EkAvmDXq-MultiMoves/ | s3raphic333 | https://www.tradingview.com/u/s3raphic333/ | 45 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// ©SignalFI
// Modified by ©s3raphic
//@version=5
indicator("MultiMoves", overlay=true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
// MultiMoves Short{{
mm_gr_name = "MultiMoves Short"
len = input.int(55, "MM Length", group=mm_gr_name)
bullcol = input.color(#3179f5, "Bullish Color", group=mm_gr_name)
bearcol = input.color(#f7525f, "Bearish Color", group=mm_gr_name)
ma1 = ta.hma(close, len)
ma2 = ta.ema(close, len)
ma3 = ta.vwma(close,len)
ma4 = ta.linreg(close, len, 1)
bull1 = close > ma1 ? 1 : 0
bull2 = close > ma2 ? 1 : 0
bull3 = close > ma3 ? 1 : 0
bull4 = close > ma4 ? 1 : 0
bear1 = close < ma1 ? -1 : 0
bear2 = close < ma2 ? -1 : 0
bear3 = close < ma3 ? -1 : 0
bear4 = close < ma4 ? -1 : 0
bulltotal = bull1 + bull2 + bull3 + bull4
beartotal = bear1 + bear2 + bear3 + bear4
avg = math.avg(ma1, ma2, ma3, ma4)
plot(avg, color = bulltotal == 4 ? color.new(bullcol,40) : na, linewidth = 4)
plot(avg, color = bulltotal == 3 ? color.new(bullcol,55) : na, linewidth = 3)
plot(avg, color = bulltotal == 2 ? color.new(bullcol,70) : na, linewidth = 2)
plot(avg, color = bulltotal == 1 ? color.new(bullcol,85) : na, linewidth = 1)
avg_plot = plot(avg, color = na)
plot(avg, color = beartotal == -4 ? color.new(bearcol,40) : na, linewidth = 4)
plot(avg, color = beartotal == -3 ? color.new(bearcol,55) : na, linewidth = 3)
plot(avg, color = beartotal == -2 ? color.new(bearcol,70) : na, linewidth = 2)
plot(avg, color = beartotal == -1 ? color.new(bearcol,85) : na, linewidth = 1)
ma1_plot = plot(ma1, color = na)
ma2_plot = plot(ma2, color = na)
ma3_plot = plot(ma3, color = na)
ma4_plot = plot(ma4, color = na)
fill(ma1_plot, avg_plot, color = input.color(color.new(#5b9cf6, 70), "Moving Average 1", group=mm_gr_name))
fill(ma2_plot, avg_plot, color = input.color(color.new(#f7525f, 70), "Moving Average 2", group=mm_gr_name))
fill(ma3_plot, avg_plot, color = input.color(color.new(#f7525f, 70), "Moving Average 3", group=mm_gr_name))
fill(ma4_plot, avg_plot, color = input.color(color.new(#5b9cf6, 70), "Moving Average 4", group=mm_gr_name))
//}
//========================================================================================================================================================
// MultiMoves Long{
mm_gr_name2 = "MultiMoves Long"
len2 = input.int(200, "MM Length", group=mm_gr_name2)
bullcol2 = input.color(#0099ff, "Bullish Color", group=mm_gr_name2)
bearcol2 = input.color(#FF0000, "Bearish Color", group=mm_gr_name2)
ma11 = ta.hma(close, len2)
ma22 = ta.ema(close, len2)
ma33 = ta.vwma(close, len2)
ma44 = ta.linreg(close, len2, 1)
bull11 = close > ma11 ? 1 : 0
bull22 = close > ma22 ? 1 : 0
bull33 = close > ma33 ? 1 : 0
bull44 = close > ma44 ? 1 : 0
bear11 = close < ma11 ? -1 : 0
bear22 = close < ma22 ? -1 : 0
bear33 = close < ma33 ? -1 : 0
bear44 = close < ma44 ? -1 : 0
bulltotal2 = bull11 + bull22 + bull33 + bull44
beartotal2 = bear11 + bear22 + bear33 + bear44
avg2 = math.avg(ma11, ma22, ma33, ma44)
plot(avg2, color = bulltotal2 == 4 ? color.new(bullcol2,10) : na, linewidth = 4)
plot(avg2, color = bulltotal2 == 3 ? color.new(bullcol2,30) : na, linewidth = 3)
plot(avg2, color = bulltotal2 == 2 ? color.new(bullcol2,50) : na, linewidth = 2)
plot(avg2, color = bulltotal2 == 1 ? color.new(bullcol2,70) : na, linewidth = 1)
avg_plot2 = plot(avg2, color = na)
plot(avg2, color = beartotal2 == -4 ? color.new(bearcol2,10) : na, linewidth = 4)
plot(avg2, color = beartotal2 == -3 ? color.new(bearcol2,30) : na, linewidth = 3)
plot(avg2, color = beartotal2 == -2 ? color.new(bearcol2,50) : na, linewidth = 2)
plot(avg2, color = beartotal2 == -1 ? color.new(bearcol2,70) : na, linewidth = 1)
ma11_plot = plot(ma11, color = na)
ma22_plot = plot(ma22, color = na)
ma33_plot = plot(ma33, color = na)
ma44_plot = plot(ma44, color = na)
fill(ma11_plot, avg_plot2, color = input.color(color.new(#ffffff, 70), "Moving Average 1", group=mm_gr_name2))
fill(ma22_plot, avg_plot2, color = input.color(color.new(#5d606b, 70), "Moving Average 2", group=mm_gr_name2))
fill(ma33_plot, avg_plot2, color = input.color(color.new(#5d606b, 70), "Moving Average 3", group=mm_gr_name2))
fill(ma44_plot, avg_plot2, color = input.color(color.new(#ffffff, 70), "Moving Average 4", group=mm_gr_name2))
//}
//========================================================================================================================================================
// Bar Color {
long4 = bulltotal == 4
long3 = bulltotal == 3
long2 = bulltotal == 2
long1 = bulltotal == 1
short4 = beartotal == -4
short3 = beartotal == -3
short2 = beartotal == -2
short1 = beartotal == -1
barcolor(long1 ? color.new(bullcol2, 70) : long2 ? color.new(bullcol2, 50) : long3 ? color.new(bullcol2, 30) : long4 ? color.new(bullcol2, 10) : short1 ? color.new(bearcol2, 70) : short2 ? color.new(bearcol2, 50) : short3 ? color.new(bearcol2, 30) : short4 ? color.new(bearcol2, 10) : na)
//}
//========================================================================================================================================================
// Crossover Alerts {
alertcondition(ta.crossover(avg, avg2), title = "Crossover", message = "MultiMoves Crossover")
alertcondition(ta.crossunder(avg, avg2), title = "Crossunder", message = "MultiMoves Crossunder")
//}} |
Strat Trail Stop by AlexsOptions | https://www.tradingview.com/script/HfAuYuG6-Strat-Trail-Stop-by-AlexsOptions/ | AlexsOptions | https://www.tradingview.com/u/AlexsOptions/ | 249 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © AlexSopa
//@version=5
indicator("Strat Trail Stop by AlexsOptions","STS by A.O",overlay=true)
timeframe = input.timeframe('D',"Timeframe Input",tooltip = "This will allow you to trail based on whatever timeframe you'd like")
timeframe2 = input.timeframe('W',"Higher Timeframe Input",tooltip = "This will filter trail signals agains the HTF Trend")
timeframe3 = input.timeframe('M', "Higher higher timeframe input",tooltip="This will filter trail signals only with HHTF and HTF trend")
gap_timeframe = input.timeframe('D',"This timeframe will be played as a gapper. It must be one of the 3 selected timeframes above.")
display_partials = input.bool(false,"Alert partials [corrective activity]")
gapper_trades = input.bool(true,"Alert gapper trades")
use_HTF_open = input.bool(false, 'Use the HTF open instead of High/Low',tooltip='This will better get you playing in the direction of continuity.')
tto_only = input.bool(true,"Only display TTOs on the chart")
vix_price = request.security("VIX",timeframe,close,barmerge.gaps_off,lookahead=barmerge.lookahead_on)
price_filter = input.int(17,"VIX Price Filter",0,99,tooltip="If vix is below this price the indicator will paint gray")
request_htf_candle(timeframe,bar) =>
[o,h,l,c] = request.security(syminfo.tickerid,timeframe,[open[bar],high[bar],low[bar],close[bar]],barmerge.gaps_off,lookahead=barmerge.lookahead_on)
[o,h,l,c]
[ltf_open,ltfh1,ltfl2,ltfc3] = request_htf_candle(timeframe,0)
[gtfo,gtfh,gtfl,gtfc] = request_htf_candle(gap_timeframe,0)
[gtfo2,gtfh2,gtfl2,gtfc2] = request_htf_candle(gap_timeframe,1)
[pdo1,pdh1,pdl1,pdc1] = request_htf_candle(timeframe,1)
[pdo2,pdh2,pdl2,pdc2] = request_htf_candle(timeframe,2)
var trail1 = 0.0
trail1:= pdh1 > pdh2 and pdl1 > pdl2 ? pdl1 : pdh2 > pdh1 and pdl1 < pdl2 ? pdh1 : trail1[1]
trail_color = close > trail1 ? color.green : close < trail1 ? color.red : color.gray
trail_color:= vix_price > price_filter ? trail_color : color.rgb(120, 123, 134, 71)
plot(trail1,'Trailing Stop [LTF]',trail_color,linewidth=2)
[htf_open,htf1,htf2,htf3] = request_htf_candle(timeframe2,0)
[pwo1,pwh1,pwl1,pwc1] = request_htf_candle(timeframe2,1)
[pwo2,pwh2,pwl2,pwc2] = request_htf_candle(timeframe2,2)
var trail2 = 0.0
trail2:= use_HTF_open ? htf_open : pwh1 > pwh2 and pwl1 > pwl2 ? pwl1 : pwh2 > pwh1 and pwl1 < pwl2 ? pwh1 : trail2[1]
trail_color2 = close > trail2 ? color.green : close < trail2 ? color.red : color.gray
trail_color2:= vix_price > price_filter ? trail_color2 : color.rgb(120, 123, 134, 71)
plot(trail2,'Trailing Stop [HTF]',trail_color2,linewidth=2)
[htf_open2,htf4,htf5,htf6] = request_htf_candle(timeframe3,0)
[pmo2,pmh2,pml2,pmc2] = request_htf_candle(timeframe3,2)
[pmo1,pmh1,pml1,pmc1] = request_htf_candle(timeframe3,1)
var trail3 = 0.0
trail3:= use_HTF_open ? htf_open2 : pmh1 > pmh2 and pml1 > pml2 ? pml1 : pmh2 > pmh1 and pml1 < pml2 ? pmh1 : trail3[1]
trail_color3 = close > trail3 ? color.green : close < trail3 ? color.red : color.gray
trail_color3:= vix_price > price_filter ? trail_color3 : color.rgb(120, 123, 134, 71)
plot(trail3,'Trailing Stop [HHTF]',trail_color3,linewidth=2)
color1_red_to_green = trail_color == color.green and trail_color[1] == color.red
color2_red_to_green = trail_color2 == color.green and trail_color2[1] == color.red
color3_red_to_green = trail_color3 == color.green and trail_color3[1] == color.red
color1_green_to_red = trail_color == color.red and trail_color[1] == color.green
color2_green_to_red = trail_color2 == color.red and trail_color2[1] == color.green
color3_green_to_red = trail_color3 == color.red and trail_color3[1] == color.green
gap_dn_gapTF = gtfo < gtfh2 and gtfo < gtfl2
gap_up_gapTF =gtfo > gtfh2 and gtfo > gtfl2
two_up_red = gtfo > gtfc
var previous_week = 0
if trail2[1] != trail2
previous_week == trail2[1]
if trail_color == color.green and trail_color[1] == color.red and trail_color2 == color.green and trail_color3 == color.green and ltfc3 > ltf_open and tto_only==false
if gap_up_gapTF == false
label.new(bar_index,high*1.01,"[" + "BUY" + "] ",color = color.green)
if trail_color == color.red and trail_color[1] == color.green and trail_color2 == color.red and trail_color3 == color.red and tto_only==false
if gap_dn_gapTF == false or gap_up_gapTF
label.new(bar_index,high*1.01,"[" + "SELL" + "] ",color = color.red)
//TFC SHIFT
if color3_red_to_green and trail_color == color.green and trail_color2 == color.green and tto_only==false
label.new(bar_index,high*1.01,"[" + "NEG-BUY" + "]",color = color.orange)
if color2_red_to_green and trail_color3 == color.green and trail_color == color.green and tto_only==false
if gap_up_gapTF == false
label.new(bar_index,high*1.01,"[" + "BUY" + "]",color = color.blue)
if color1_green_to_red and trail_color2 == color.green and trail_color3 == color.green and display_partials and tto_only==false
label.new(bar_index,high*1.01,"[" + "P" + "]",color = color.purple)
if color1_green_to_red and gap_up_gapTF and two_up_red and tto_only==false
if gapper_trades
label.new(bar_index,high*1.01,"[" + "G-SELL" + "]",color = color.rgb(215, 4, 4))
tto_signal = trail_color3 == color.green and trail_color2 == color.red and close[5] > trail2
if tto_signal and tto_signal[1] != true
label.new(bar_index,high*1.005,"[TTO]",color=color.orange)
//if color1_green_to_red and trail_color3 == color.green and trail_color2 == color.green
//label.new(bar_index,high*1.01,"[" + "C/A" + "]",color = color.yellow)
// plotshape(long_signal,"Long",shape.circle,location.belowbar,color.green)
// plotshape(short_signal,"Short",shape.circle,location.abovebar,color.red) |
Vector2DrawTriangle | https://www.tradingview.com/script/IiclD701-Vector2DrawTriangle/ | RicardoSantos | https://www.tradingview.com/u/RicardoSantos/ | 17 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RicardoSantos
//@version=5
// @description Functions to draw a triangle and manipulate its properties.
library(title='Vector2DrawTriangle')
// .
// references:
// https://docs.unity3d.com/ScriptReference/Vector2.html
// https://gist.github.com/winduptoy/a1aa09c3499e09edbd33
// https://github.com/dogancoruh/Javascript-Vector2/blob/master/js/vector2.js
// https://gist.github.com/Dalimil/3daf2a0c531d7d030deb37a7bfeff454
// https://gist.github.com/jeantimex/7fa22744e0c45e5df770b532f696af2d
// https://gist.github.com/volkansalma/2972237
// .
//#region Imports:
import RicardoSantos/CommonTypesMath/1 as TMath
import RicardoSantos/CommonTypesDrawing/1 as TDraw
import RicardoSantos/Vector2/1 as Vector2
import RicardoSantos/Vector2DrawLine/1 as line
//#endregion
//#region Constructor:
// new () {
// @function Draws a triangle with background fill using line prototype.
// @param a v2 . Vector2 object, in the form `(x, y)`.
// @param b v2 . Vector2 object, in the form `(x, y)`.
// @param c v2 . Vector2 object, in the form `(x, y)`.
// @param xloc string . Type of axis unit, bar_index or time.
// @param bg_color color . Color of the background.
// @param line_color color . Color of the line.
// @param line_style string . Style of the line.
// @param line_width int . Width of the line.
// @returns Triangle object.
export new (
TMath.Vector2 a ,
TMath.Vector2 b ,
TMath.Vector2 c ,
string xloc = 'bi' ,
color bg_color = #2196f3,
color line_color = #2196f3,
string line_style = 'sol' ,
int line_width = 1 ) =>
TMath.Segment2 _ab = TMath.Segment2.new(a, b)
TMath.Segment2 _bc = TMath.Segment2.new(c, b)
TMath.Segment2 _ca = TMath.Segment2.new(c, a)
line _line1 = line.new(_ab, xloc, extend.none, line_color, line_style, line_width)
line _line2 = line.new(_bc, xloc, extend.none, line_color, line_style, line_width)
line _line3 = line.new(_ca, xloc, extend.none, line_color, line_style, line_width)
linefill _fill = linefill.new(_line1, _line2, bg_color)
TDraw.Triangle.new(_line1, _line2, _line3, _fill)
// }
// copy () {
// @function Copy a existing triangle object.
// @param this Triangle . Source triangle.
// @returns Triangle.
export method copy (TDraw.Triangle this) =>
TDraw.Triangle.copy(this)
// }
// delete () {
// @function Delete all the underlying object properties (line, fill).
// @param this `Triangle` Source triangle.
// @returns `void`.
export method delete (TDraw.Triangle this) =>
this.ab.delete()
this.bc.delete()
this.ca.delete()
this.fill.delete()
// }
//#endregion
//#region Properties:
// set_position_a () {
// @function Set the position of corner `a` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Triangle.
export method set_position_a (TDraw.Triangle this, int x, float y) =>
this.ab.set_xy1(x, y)
this.ca.set_xy2(x, y)
this
// @function Set the position of corner `a` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param position Vector2 . New position.
// @returns Source Triangle.
export method set_position_a (TDraw.Triangle this, TMath.Vector2 position) =>
this.ab.set_xy1(int(position.x), position.y)
this.ca.set_xy2(int(position.x), position.y)
this
// }
// set_position_b () {
// @function Set the position of corner `b` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Triangle.
export method set_position_b (TDraw.Triangle this, int x, float y) =>
this.ab.set_xy2(x, y)
this.bc.set_xy2(x, y) // the origin/target are inverted because of the fill
this
// @function Set the position of corner `b` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param position Vector2 . New position.
// @returns Source Triangle.
export method set_position_b (TDraw.Triangle this, TMath.Vector2 position) =>
this.ab.set_xy2(int(position.x), position.y)
this.bc.set_xy2(int(position.x), position.y) // the origin/target are inverted because of the fill
this
// }
// set_position_c () {
// @function Set the position of corner `c` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Triangle.
export method set_position_c (TDraw.Triangle this, int x, float y) =>
this.bc.set_xy1(x, y) // the origin/target are inverted because of the fill
this.ca.set_xy1(x, y)
this
// @function Set the position of corner `c` (modifies source triangle).
// @param this Triangle . Source triangle.
// @param position Vector2 . New position.
// @returns Source Triangle.
export method set_position_c (TDraw.Triangle this, TMath.Vector2 position) =>
this.bc.set_xy1(int(position.x), position.y) // the origin/target are inverted because of the fill
this.ca.set_xy1(int(position.x), position.y)
this
// }
// set_line_style () {
// @function Update triangle style options (modifies Source triangle).
// @param this Triangle . Source triangle.
// @param bg_color color . Color of the background.
// @param line_color color . Color of the line.
// @param line_style string . Style of the line.
// @param line_width int . Width of the line.
// @returns Source Triangle.
export method set_style (
TDraw.Triangle this ,
color bg_color = #2196f3,
color line_color = #2196f3,
string line_style = 'sol' ,
int line_width = 1 ) =>
linefill.set_color(this.fill, bg_color)
this.ab.set_color(line_color) , this.ab.set_width(line_width) , this.ab.set_style(line_style)
this.bc.set_color(line_color) , this.bc.set_width(line_width) , this.bc.set_style(line_style)
this.ca.set_color(line_color) , this.ca.set_width(line_width) , this.ca.set_style(line_style)
this
// TEST: 20230218 RS
// tstyle = input.string('sol', options=[line.style_solid, line.style_dashed, line.style_dotted])
// tlinecol = input.color(#e3e3e3)
// tbgcol = input.color(#e3e3e3)
// tlinew = input.int(1)
// if barstate.islast
// _a = Vector2.new(bar_index + 0.0, 0.0)
// _b = Vector2.new(bar_index + 100.0, 50.0)
// _c = Vector2.new(bar_index + 200.0, 0.0)
// tri = new(_a, _b, _c)
// tri.set_style(tbgcol, tlinecol, tstyle, tlinew)
// }
// set_bg_color () {
// @function Update triangle style options (modifies Source triangle).
// @param this Triangle . Source triangle.
// @param bg_color color . Color of the background.
// @returns Source Triangle.
export method set_bg_color (
TDraw.Triangle this ,
color bg_color = #2196f3) =>
linefill.set_color(this.fill, bg_color)
this
// }
// set_line_color () {
// @function Update triangle style options (modifies Source triangle).
// @param this Triangle . Source triangle.
// @param line_color color . Color of the line.
// @returns Source Triangle.
export method set_line_color (
TDraw.Triangle this ,
color line_color = #2196f3) =>
this.ab.set_color(line_color)
this.bc.set_color(line_color)
this.ca.set_color(line_color)
this
// }
// set_line_style () {
// @function Update triangle style options (modifies Source triangle).
// @param this Triangle . Source triangle.
// @param line_style string . Style of the line.
// @returns Source Triangle.
export method set_line_style (
TDraw.Triangle this ,
string line_style = 'sol' ) =>
this.ab.set_style(line_style)
this.bc.set_style(line_style)
this.ca.set_style(line_style)
this
// }
// set_line_width () {
// @function Update triangle style options (modifies Source triangle).
// @param this Triangle . Source triangle.
// @param line_width int . Width of the line.
// @returns Source Triangle.
export method set_line_width (
TDraw.Triangle this ,
int line_width = 1 ) =>
this.ab.set_width(line_width)
this.bc.set_width(line_width)
this.ca.set_width(line_width)
this
// }
//#endregion
//#region Instance Methods:
// move () {
// @function Move triangle by provided amount (modifies source triangle).
// @param this Triangle . Source triangle.
// @param x float . Amount to move the vertices of the triangle in the x axis.
// @param y float . Amount to move the vertices of the triangle in the y axis.
// @returns Source Triangle.
export method move (TDraw.Triangle this, int x=0, float y=0.0) =>
int _ax = this.ab.get_x1() , float _ay = this.ab.get_y1()
int _bx = this.bc.get_x2() , float _by = this.bc.get_y2() // the origin/target are inverted because of the fill
int _cx = this.ca.get_x1() , float _cy = this.ca.get_y1()
this.ab.set_xy1(_ax + x, _ay + y) , this.ab.set_xy2(_bx + x, _by + y)
this.bc.set_xy2(_bx + x, _by + y) , this.bc.set_xy1(_cx + x, _cy + y) // the origin/target are inverted because of the fill
this.ca.set_xy1(_cx + x, _cy + y) , this.ca.set_xy2(_ax + x, _ay + y)
this
// @function Move triangle by provided amount (modifies source triangle).
// @param this Triangle . Source triangle.
// @param amount Vector2 . Amount to move the vertices of the triangle in the x and y axis.
// @returns Source Triangle.
export method move (TDraw.Triangle this, TMath.Vector2 amount) =>
this.move(int(amount.x), amount.y)
// TEST: 20230218 RS
// mx = input.int(0, step=10)
// my = input.float(0.0, step=10.0)
// if barstate.islast
// _a = Vector2.new(bar_index + 0.0, 0.0)
// _b = Vector2.new(bar_index + 100.0, 50.0)
// _c = Vector2.new(bar_index + 200.0, 0.0)
// tri = new(_a, _b, _c)
// tri.move(mx, my)
// }
// rotate_around () {
// @function Rotate source triangle around a center (modifies source triangle).
// @param this Triangle . Source triangle.
// @param center Vector2 . Center coordinates of the rotation.
// @param angle float . Value of angle in degrees.
// @returns Source Triangle.
export method rotate_around (TDraw.Triangle this, TMath.Vector2 center, float angle) =>
int _ax = this.ab.get_x1() , float _ay = this.ab.get_y1()
int _bx = this.bc.get_x2() , float _by = this.bc.get_y2() // the origin/target are inverted because of the fill
int _cx = this.ca.get_x1() , float _cy = this.ca.get_y1()
_a = Vector2.new(_ax, _ay).rotate_around(center, angle)
_b = Vector2.new(_bx, _by).rotate_around(center, angle)
_c = Vector2.new(_cx, _cy).rotate_around(center, angle)
this.ab.set_xy1(int(_a.x), _a.y) , this.ab.set_xy2(int(_b.x), _b.y)
this.bc.set_xy2(int(_b.x), _b.y) , this.bc.set_xy1(int(_c.x), _c.y) // the origin/target are inverted because of the fill
this.ca.set_xy1(int(_c.x), _c.y) , this.ca.set_xy2(int(_a.x), _a.y)
this
// @function Rotate source triangle around a center (modifies source triangle).
// @param this Triangle . Source triangle.
// @param center_x int . Center coordinates of the rotation.
// @param center_y float . Center coordinates of the rotation.
// @param angle float . Value of angle in degrees.
// @returns Source Triangle.
export method rotate_around (TDraw.Triangle this, int center_x, float center_y, float angle) =>
this.rotate_around(Vector2.new(center_x, center_y), angle)
// TEST: 20230218 RS
// mx = input.int(50, step=10)
// my = input.float(50.0, step=10.0)
// degree = input.float(0.0, step=10.0)
// if barstate.islast
// _a = Vector2.new(bar_index + 0.0, 0.0)
// _b = Vector2.new(bar_index + 100.0, 50.0)
// _c = Vector2.new(bar_index + 200.0, 0.0)
// _center = Vector2.new(bar_index + mx, my)
// tri = new(_a, _b, _c)
// tri.rotate_around(_center, degree)
// }
//#endregion
|
MathComplexNumbers | https://www.tradingview.com/script/web2D0Tn-MathComplexNumbers/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 3 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
//@description A set of utility functions to handle complex numbers without arrays.
library("MathComplex")
//@function Complex type.
export type complex
float re
float im
//@function Convert a complex number into a tuple
//@param complex_number is a complex type
//@returns float tuple
export complex_tuple(complex complex_number)=>
[complex_number.re, complex_number.im]
//@function Convert a complex number into a tuple
//@param complex_number is a complex type
//@returns float tuple
export ct(complex complex_number)=>
[complex_number.re, complex_number.im]
//@function Get the real part of the complex number
//@peram complex_number is a complex type
//@returns float
export get_real(complex complex_number)=>
complex_number.re
//@function Get the imaginary part of the complex number
//@peram complex_number is a complex type
//@returns float
export get_imaginary(complex complex_number)=>
complex_number.im
//@function Get the real part of the complex number
//@peram complex_number is a complex type
//@returns float
export re(complex complex_number)=>
get_real(complex_number)
//@function Get the imaginary part of the complex number
//@peram complex_number is a complex type
//@returns float
export im(complex complex_number)=>
get_imaginary(complex_number)
//@function Adds complex number A to B, in the form:
// [a.re + b.re, a.im + b.im]
//@peram Complex number A
//@peram Complex number B
//@returns complex
export add(complex a, complex b)=>
complex.new(a.re + b.re, a.im + b.im)
//@function Subtract B from A, in the form:
// [a.re - b.re, a.im - b.im]
//@param Complex number A
//@param Complex number B
//@returns complex
export subtract(complex a, complex b)=>
complex.new(a.re - b.re, a.im - b.im)
//@function Computes the conjugate of complex_number by reversing the sign of the imaginary part.
//@param Complex number
//@returns complex
export conjugate(complex complex_number)=>
complex.new(complex_number.re, -1 * complex_number.im)
//@function Multiply A with B, in the form:
// [(a.re * b.re) - (a.im * b.im), (a.re * b.im) + (a.im * b.re)]
//@param Complex number A
//@param Complex number B
//@returns complex
export multiply(complex a, complex b)=>
complex.new(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re)
//@function Divide A with B, in the form:
// [(a.re * b.re) - (a.im * b.im), (a.re * b.im) + (a.im * b.re)]
//@param Complex number A
//@param Complex number B
//@returns complex
export divide(complex a, complex b)=>
divident = multiply(a, conjugate(b))
divider = math.pow(b.re, 2) + math.pow(b.im, 2)
complex.new(divident.re / divider, divident.im / divider)
//@function Computes the reciprocal or inverse of complex_number.
//@param Complex number
//@returns complex
export reciprocal(complex complex_number)=>
if complex_number.re == 0 and complex_number.im == 0
complex.new(0, 0)
else
divide(complex.new(1, 0), complex_number)
//@function Inverse of complex_number, in the form: [1/complex_number.re, 1/complex_number.im]
//@param Complex number
//@returns complex
export inverse(complex complex_number)=>
if complex_number.re != 0 and complex_number.im != 0
float d = complex_number.re * complex_number.re + complex_number.im * complex_number.im
complex.new(complex_number.re / d, (0 - complex_number.im) / d)
else
complex.new(0, 0)
//@function Negative of complex_number, in the form: [-complex_number.re, -complex_number.im]
//@param complex_number float array, pseudo complex number in the form of a array [real, imaginary].
//@returns complex
export negative(complex complex_number)=>
complex.new(-complex_number.re, -complex_number.im)
//@function Exponential of complex_number.
//@param Complex number
//@returns complex
export exponential(complex complex_number)=>
er = math.exp(complex_number.re)
complex.new(er * math.cos(complex_number.im), er * math.sin(complex_number.im))
//@function Ceils complex_number.
//@param Complex number
//@param digits int, digits to use as ceiling.
//@returns complex
export ceil(complex complex_number, int digits)=>
places = math.pow(10, digits)
complex.new(math.ceil(complex_number.re * places) / places, math.ceil(complex_number.im * places) / places)
//@function Radius(magnitude) of complex_number, in the form: [sqrt(pow(complex_number))]
// This is defined as its distance from the origin (0,0) of the complex plane.
//@param Complex number
//@returns float
export radius(complex complex_number)=>
math.sqrt(math.pow(complex_number.re, 2) + math.pow(complex_number.im, 2))
// EXAMPLE USE
test = complex.new(50, 2)
real_t = test.re
real_i = test.im
test_array = array.new<complex>(1, complex.new(50, 2))
[real, imaginary] = complex_tuple(array.get(test_array, 0))
plot(real)
plot(imaginary) |
CandleLib | https://www.tradingview.com/script/nWaH7l6z-candlelib/ | Hamster-Coder | https://www.tradingview.com/u/Hamster-Coder/ | 1 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Hamster-Coder
//@version=5
// @description TODO: add library description here
library("CandleLib", overlay = true)
export candle_body() =>
math.abs(open-close)
// @variable Size of the candle body
candle_body = candle_body()
export candle_shadow_top() =>
high - math.max(open, close)
// @variable Size of the candle top shadow
candle_shadow_top = candle_shadow_top()
export candle_shadow_bottom() =>
math.min(open, close) - low
// @variable Size of the candle bottom shadow
candle_shadow_bottom = candle_shadow_bottom()
export candle_body_sma(int length = 50) =>
ta.sma(candle_body, length)
// @variable Size of the candle top shadow
candle_body_sma = candle_body_sma()
// @function Get approximate candle zero size
// @param maxSize mitiplier to avarage body size of the candle
export zero(float maxSize = 0.02) =>
candle_body_sma * maxSize
zero = zero()
// @variable Is candle is 'Dodge'
export candle_type_dodge() =>
candle_body <= zero and candle_shadow_top > zero and candle_shadow_bottom > zero
candle_type_dodge = candle_type_dodge()
export candle_type_spin() =>
candle_type_dodge == false and candle_shadow_top > candle_body * 3 and candle_shadow_bottom > candle_body * 3
candle_type_spin = candle_type_spin()
export candle_type_marubotsu() =>
candle_shadow_top <= zero and candle_shadow_bottom <= zero
candle_type_marubotsu = candle_type_marubotsu()
export candle_type_hammer() =>
candle_shadow_top < zero and candle_body > zero and candle_shadow_bottom > candle_body * 3
candle_type_hammer = candle_type_hammer()
export candle_type_hammer_inverted() =>
candle_shadow_top > candle_body * 3 and candle_body > zero and candle_shadow_bottom < zero
candle_type_hammer_inverted = candle_type_hammer_inverted()
// trends
export trend_candle() =>
float result = 0
if (candle_body > zero)
result := math.sign(close - open)
result
trend_candle = trend_candle()
export trend_volume() =>
math.sign(volume - volume[1])
export trend_candle_changed() =>
result = false
if (trend_candle[0] != 0)
idx = 1
while (true)
if (trend_candle[idx] == 0)
idx += 1
continue
result := trend_candle[0] != trend_candle[idx]
break
result
trend_candle_changed = trend_candle_changed()
export trend_reversal_trough_dodge() =>
candle_type_dodge[1] and trend_candle() != trend_candle()[2] and candle_body > candle_body[2] * 0.618 and (trend_candle() ? candle_shadow_top < candle_body : candle_shadow_bottom < candle_body)
export trend_reversal_trough_hammer_inverted() =>
trend_candle()[0] < 0 and candle_type_hammer_inverted[1] and trend_candle()[1] < 0 and trend_candle()[2] > 0 and candle_body > zero
export trend_reversal_trough_hammer() =>
trend_candle()[0] > 0 and candle_type_hammer[1] and trend_candle()[1] > 0 and trend_candle()[2] < 0 and candle_body > zero
export trend_reversal() =>
candle_body[1] > zero[1] and candle_body[0] > zero[0] and trend_candle_changed[0] and candle_body[0] + zero[0] > candle_body[1]
|
market sessions by sellstreet | https://www.tradingview.com/script/mqQDkZSx-market-sessions-by-sellstreet/ | sellstreet | https://www.tradingview.com/u/sellstreet/ | 131 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © sellstreet
//@version=5
indicator("market sessions by sellstreet", overlay=true, precision=0,
max_bars_back=1500, max_lines_count=500, max_labels_count=500, max_boxes_count=500)
// format=format.price, precision=0, scale=scale.none)
gr_1="HISTORY"
Show_Opens = input.bool(defval=true, title = "Opens", inline="0_1", group=gr_1)
Only_Last_Opens = input.bool(defval=true, title = "Only Last Opens", inline="0_1", group=gr_1)
Show_Sessions = input.bool(defval=true, title = "Sessions", inline="0_2", group=gr_1)
Only_Last_Sessions = input.bool(defval=false, title = "Only Last Sessions", inline="0_2", group=gr_1)
Show_Days_VLines = input.bool(defval=false, title = "Days Lines", inline="0_3", group=gr_1)
// Show_Days_Bg = input.bool(defval=false, title = "Days Background", inline="0_3", group=gr_1)
gr_2="OPENS"
ULine_Width = input.int(defval=1, title = "Line Width", minval=0, maxval=7, step=1, group=gr_2)
Show_Daily_Open = input.bool(defval=true, title = "Daily Open", inline = "2_1", group=gr_2)
Col_Daily_Open = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_1", group=gr_2)
Show_Weekly_Open = input.bool(defval=true, title = "Weekly Open", inline = "2_1", group=gr_2)
Col_Weekly_Open = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_1", group=gr_2)
Show_Monthly_Open = input.bool(defval=true, title = "Monthly Open", inline = "2_2", group=gr_2)
Col_Monthly_Open = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_2", group=gr_2)
Show_NewYork_Midnight = input.bool(defval=true, title = "New York Midnight", inline = "2_2", group=gr_2)
Col_NewYork_Midnight = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_2", group=gr_2)
Show_Previous_Daily_High = input.bool(defval=true, title = "Previous Daily High", inline = "2_3", group=gr_2)
Col_Previous_Daily_High = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_3", group=gr_2)
Show_Previous_Daily_Low = input.bool(defval=true, title = "Previous Daily Low", inline = "2_3", group=gr_2)
Col_Previous_Daily_Low = input.color(color.rgb(0, 0, 0, 0), "", inline = "2_3", group=gr_2)
SLine_Width = input.int(defval=0, title = "Session Line Width", minval=0, maxval=7, step=1)
// gr_4="SYDNEY"
// Show_Sydney = input.bool(defval=false, title = "SYDNEY", inline="4_1", group=gr_4)
// Sydney_Display = input.string(defval="Border", title = "", options=["Border", "Filled Box"], inline="4_1", group=gr_4)
// Title_Col_Sydney = input.color(color.rgb(88, 43, 143, 20), "Title", inline="4_2", group=gr_4)
// Background_Col_Sydney = input.color(color.rgb(88, 43, 143, 65), "Background", inline="4_2", group=gr_4)
gr_3="ASIA"
Show_Asia = input.bool(defval=true, title = "ASIA", inline="3_1", group=gr_3)
Asia_Display = input.string(defval="Filled Box", title = "", options=["Border", "Filled Box"], inline="3_1", group=gr_3)
Title_Col_Asia = input.color(color.rgb(0, 0, 0, 0), "Title", inline="3_2", group=gr_3)
Background_Col_Asia = input.color(color.rgb(230, 184, 0, 90), "Background", inline="3_2", group=gr_3)
gr_8="Frankfurt"
Show_Frankfurt = input.bool(defval=true, title = "Frankfurt", inline="8_1", group=gr_8)
Frankfurt_Display = input.string(defval="Filled Box", title = "", options=["Border", "Filled Box"], inline="8_1", group=gr_8)
Title_Col_Frankfurt = input.color(color.rgb(0, 0, 0, 0), "Title", inline="8_2", group=gr_8)
Background_Col_Frankfurt = input.color(color.rgb(204, 51, 0, 80), "Background", inline="8_2", group=gr_8)
gr_5="LONDON"
Show_London = input.bool(defval=true, title = "London", inline="5_1", group=gr_5)
London_Display = input.string(defval="Filled Box", title = "", options=["Border", "Filled Box"], inline="5_1", group=gr_5)
Title_Col_London = input.color(color.rgb(0, 0, 0, 0), "Title", inline="5_2", group=gr_5)
Background_Col_London = input.color(color.rgb(128, 170, 255, 90), "Background", inline="5_2", group=gr_5)
gr_6="NEW YORK"
Show_NewYork = input.bool(defval=true, title = "NEW YORK", inline="6_1", group=gr_6)
NewYork_Display = input.string(defval="Filled Box", title = "", options=["Border", "Filled Box"], inline="6_1", group=gr_6)
Title_Col_NewYork = input.color(color.rgb(0, 0, 0, 0), "Title", inline="6_2", group=gr_6)
Background_Col_NewYork = input.color(color.rgb(179,102,255, 90), "Background", inline="6_2", group=gr_6)
gr_7="CBDR"
Show_CBDR = input.bool(defval=true, title = "CBDR", inline="7_1", group=gr_7)
CBDR_Display = input.string(defval="Filled Box", title = "", options=["Border", "Filled Box"], inline="7_1", group=gr_7)
Title_Col_CBDR = input.color(color.rgb(0, 0, 0, 0), "Title", inline="7_2", group=gr_7)
Background_Col_CBDR = input.color(color.rgb(255,102,102, 90), "Background", inline="7_2", group=gr_7)
// ----- Utils -----
// https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
// https://www.forexmarkethours.com/
__Get_Price_At_Midnight(Timezone="America/New_York") =>
var float res_open = na
session_str = "0000-0000:1234567" // Sun to Sat
if time("D", session_str, Timezone) != time("D", session_str, Timezone)[1]
res_open := open
res_open
Get_Price_At_Midnight(Timezone="America/New_York") =>
float Midnight_Price = request.security(syminfo.tickerid, "60", __Get_Price_At_Midnight(Timezone),
gaps=barmerge.gaps_off, lookahead=barmerge.lookahead_on)
Midnight_Price
Session_Range_Info(Range="0800-1600", Timezone="America/New_York") =>
time_val = time("1", Range, Timezone)
in_range = not na(time_val) ? true : false
is_begin = in_range and na(time("1", Range, Timezone)[1])
[in_range, is_begin, time_val]
Draw_Label(XLoc, YPrice, Text, TColor) =>
nlabel = label.new(x=XLoc, y=YPrice, text=Text, textcolor=TColor, size=size.normal,
xloc=xloc.bar_time, yloc=yloc.price, text_font_family=font.family_monospace, style=label.style_none, textalign=text.align_center)
nlabel
// ----- Calc and Show Opens -----
float Daily_Open = Show_Opens and Show_Daily_Open ? request.security(syminfo.tickerid, "D", open, lookahead=barmerge.lookahead_on) : na
float Weekly_Open = Show_Opens and Show_Weekly_Open ? request.security(syminfo.tickerid, "W", open, lookahead=barmerge.lookahead_on) : na
float Monthly_Open = Show_Opens and Show_Monthly_Open ? request.security(syminfo.tickerid, "M", open, lookahead=barmerge.lookahead_on) : na
float NewYork_Midnight = Show_Opens and Show_NewYork_Midnight ? Get_Price_At_Midnight("America/New_York") : na
float Previous_Daily_High = Show_Opens and Show_Previous_Daily_High ? request.security(syminfo.tickerid, "D", high[1], lookahead=barmerge.lookahead_on) : na
float Previous_Daily_Low = Show_Opens and Show_Previous_Daily_Low ? request.security(syminfo.tickerid, "D", low[1], lookahead=barmerge.lookahead_on) : na
// var line[] DP_Lines_Arr = array.new_line(6)
Draw_Part_Line(XStart, XEnd, YPrice, Text, LColor, LWidth) =>
line.new(x1=XStart, y1=YPrice, x2=XEnd, y2=YPrice, xloc=xloc.bar_time, color=LColor, width=LWidth, style=line.style_solid)
Draw_Label(XEnd, YPrice, Text, LColor)
// -- Daily_Open --
if ta.change(Daily_Open, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 24 * 3600 * 1000 // 24 hours
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
// Draw_Label(XStart, low, str.format("LBT: {0}", last_bar_time - XEnd), color.maroon)
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, Daily_Open, "DO", Col_Daily_Open, ULine_Width)
// Draw_Part_Line(XStart, XEnd, Daily_Open, "DO", Col_Daily_Open, ULine_Width)
// -- Weekly_Open --
if ta.change(Weekly_Open, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 7 * 24 * 3600 * 1000 // 7 days
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, Weekly_Open, "WO", Col_Weekly_Open, ULine_Width)
// Draw_Part_Line(XStart, XEnd, Weekly_Open, "WO", Col_Weekly_Open, ULine_Width)
// -- Monthly_Open --
if ta.change(Monthly_Open, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 30 * 24 * 3600 * 1000 // 30 days
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, Monthly_Open, "MO", Col_Monthly_Open, ULine_Width)
// Draw_Part_Line(XStart, XEnd, Monthly_Open, "MO", Col_Monthly_Open, ULine_Width)
// ----- Calc and Show New York Midnight -----
// var bool CharSS = false
// CharSS := false
if ta.change(NewYork_Midnight, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 24 * 3600 * 1000 // 24 hours
// hval = hour(XStart, "America/New_York")
if not na(time("1", "1700-1800:1", "America/New_York"))
XEnd := XStart + 7 * 3600 * 1000 // 7 hour
// CharSS := true
// else
// CharSS := false
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, NewYork_Midnight, "NYM", Col_NewYork_Midnight, ULine_Width)
// Draw_Part_Line(XStart, XEnd, NewYork_Midnight, "NYM", Col_NewYork_Midnight, ULine_Width)
// triangle char: ▲ ▼ ◄ ►
// plotchar(CharSS, char='▼', location=location.top, color=color.teal, size=size.normal)
// ----- Previous Daily High -----
if ta.change(Previous_Daily_High, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 24 * 3600 * 1000 // 24 hours
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, Previous_Daily_High, "PDH", Col_Previous_Daily_High, ULine_Width)
// Draw_Part_Line(XStart, XEnd, Previous_Daily_High, "PDH", Col_Previous_Daily_High, ULine_Width)
// ----- Previous Daily Low -----
if ta.change(Previous_Daily_Low, 1) != 0
XStart = time(timeframe.period, "0000-0000:1234567")
XEnd = XStart + 24 * 3600 * 1000 // 24 hours
is_last_line = last_bar_time - XEnd < 3600 * 1000 // less than 1 hour
is_draw = Only_Last_Opens ? is_last_line : true
if is_draw
Draw_Part_Line(XStart, XEnd, Previous_Daily_Low, "PDL", Col_Previous_Daily_Low, ULine_Width)
// Draw_Part_Line(XStart, XEnd, Previous_Daily_Low, "PDL", Col_Previous_Daily_Low, ULine_Width)
// plot(Daily_Open, color=Col_Daily_Open, linewidth=ULine_Width, title="Daily Open", editable=false, style=plot.style_steplinebr)
// plot(Weekly_Open, color=Col_Weekly_Open, linewidth=ULine_Width, title="Weekly Open", editable=false, style=plot.style_steplinebr)
// plot(Monthly_Open, color=Col_Monthly_Open, linewidth=ULine_Width, title="Monthly Open", editable=false, style=plot.style_steplinebr)
// plot(NewYork_Midnight, color=Col_NewYork_Midnight, linewidth=ULine_Width, title="New York Midnight", editable=false, style=plot.style_steplinebr)
// plot(Previous_Daily_High, color=Col_Previous_Daily_High, linewidth=ULine_Width, title="Previous Daily High", editable=false, style=plot.style_steplinebr)
// plot(Previous_Daily_Low, color=Col_Previous_Daily_Low, linewidth=ULine_Width, title="Previous Daily Low", editable=false, style=plot.style_steplinebr)
// ----- Calc and Show Sessions -----
arr_count = 8
var float[] CHigh_Arr = array.new_float(arr_count)
var float[] CLow_Arr = array.new_float(arr_count)
var box[] Box_Arr = array.new_box(arr_count)
var label[] Label_Arr = array.new_label(arr_count)
var bool[] InRange_Arr = array.new_bool(arr_count)
Session_Draw(SLabel="London", Session_Range="0700-1600", HoursDur=9, Timezone="Greenwich", CI=0,
Display_Type="Border", SLine_Width=2, Title_Col=color.maroon, Background_Col=color.aqua) =>
[in_range, is_begin, time_val] = Session_Range_Info(Session_Range, Timezone)
array.set(InRange_Arr, CI, in_range)
if is_begin
end_time = time_val + (HoursDur - 1) * 3600 * 1000 // add Hours Duration
is_last_box = last_bar_time - time_val < 24 * 3600 * 1000 // less than 24 hour
is_draw = Only_Last_Sessions ? is_last_box : true
if is_draw
array.set(CHigh_Arr, CI, high)
array.set(CLow_Arr, CI, low)
NLabel = Draw_Label(time_val + (HoursDur / 2) * 3600 * 1000, high * 1.005, SLabel, Title_Col)
array.set(Label_Arr, CI, NLabel)
bg_color = Background_Col // Display_Type == "Filled Box"
if Display_Type == "Border"
bg_color := color.new(Background_Col, 100)
NBox = box.new(time_val, high * 1.001, end_time, low * 0.999, xloc=xloc.bar_time,
border_color=Title_Col, border_width=SLine_Width, border_style=line.style_solid, bgcolor=bg_color)
array.set(Box_Arr, CI, NBox)
else
array.set(CHigh_Arr, CI, na)
array.set(CLow_Arr, CI, na)
array.set(Label_Arr, CI, na)
array.set(Box_Arr, CI, na)
if in_range and not is_begin
Cur_High = array.get(CHigh_Arr, CI)
ncHigh = math.max(high, Cur_High)
array.set(CHigh_Arr, CI, ncHigh)
Cur_Low = array.get(CLow_Arr, CI)
ncLow = math.min(low, Cur_Low)
array.set(CLow_Arr, CI, ncLow)
Cur_Label = array.get(Label_Arr, CI)
label.set_y(Cur_Label, ncHigh)
Cur_Box = array.get(Box_Arr, CI)
box.set_top(Cur_Box, ncHigh)
box.set_bottom(Cur_Box, ncLow)
// ----- Sydney, AEDT, UTC +11, with DST -----
// if Show_Sessions and Show_Sydney
// Session_Draw("Sydney", "0700-1600", 9, "Australia/Sydney", 0, Sydney_Display, SLine_Width, Title_Col_Sydney, Background_Col_Sydney)
// ----- Asia, JST, UTC +9, not DST -----
if Show_Sessions and Show_Asia
Session_Draw("Asia", "0800-1700", 9, "Asia/Tokyo", 1, Asia_Display, SLine_Width, Title_Col_Asia, Background_Col_Asia)
// ----- London, GMT, UTC +0, not DST -----
if Show_Sessions and Show_London
Session_Draw("London", "0700-1600", 9, "Greenwich", 2, London_Display, SLine_Width, Title_Col_London, Background_Col_London)
// plotchar(array.get(InRange_Arr, 0), "in_range_London ", "▲", location.bottom, size=size.tiny, color=color.maroon, editable=false)
// ----- New York, EDT, UTC -4, with DST -----
if Show_Sessions and Show_NewYork
Session_Draw("New York", "0800-1700", 9, "America/New_York", 3, NewYork_Display, SLine_Width, Title_Col_NewYork, Background_Col_NewYork)
// plotchar(array.get(InRange_Arr, 1), "in_range_NewYork ", "▲", location.bottom, size=size.tiny, color=color.maroon, editable=false)
// ----- Central Bank Dealers Range -----
if Show_Sessions and Show_CBDR
Session_Draw("CBDR", "2000-0000", 4, "Greenwich", 4, CBDR_Display, SLine_Width, Title_Col_CBDR, Background_Col_CBDR)
// // ----- Frankfurt Modify-----
if Show_Sessions and Show_Frankfurt
Session_Draw("Frankfurt", "0200-0300", 2, "America/New_York", 5, Frankfurt_Display, SLine_Width, Title_Col_Frankfurt, Background_Col_Frankfurt)
// // ----- Hong Kong -----
// if Show_Sessions and Show_HongKong
// Session_Draw("Hong Kong", "0100-1000", 9, "Asia/Hong_Kong", 5, HongKong_Display, SLine_Width, Title_Col_HongKong, Background_Col_HongKong)
//
// // ----- Singapore -----
// if Show_Sessions and Show_Singapore
// Session_Draw("Singapore", "0100-1000", 9, "Asia/Singapore", 6, Singapore_Display, SLine_Width, Title_Col_Singapore, Background_Col_Singapore)
// ----- Show Days -----
// Days Utils
dd_ses_str = "0000-0000:1234567"
dd_tz = syminfo.timezone
newDay = ta.change(time("D", dd_ses_str, syminfo.timezone))
LineLengthMult = 100
LineLength = ta.atr(100) * LineLengthMult
bgPlot2 = time(timeframe.period)
isMon() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.monday ? 1 : 0
isTue() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.tuesday ? 1 : 0
isWed() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.wednesday ? 1 : 0
isThu() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.thursday ? 1 : 0
isFri() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.friday ? 1 : 0
isSat() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.saturday ? 1 : 0
isSun() => dayofweek(time("D", dd_ses_str, dd_tz), dd_tz) == dayofweek.sunday ? 1 : 0
txtMon = "M\no\nn\nd\na\ny"
txtTue = "T\nu\ne\ns\nd\na\ny"
txtWed = "W\ne\nd\nn\ne\ns\nd\na\ny"
txtThu = "T\nh\nu\nr\ns\nd\na\ny"
txtFri = "F\nr\ni\nd\na\ny"
txtSat = "S\na\nt\nu\nr\nd\na\ny"
txtSun = "S\nu\nn\nd\na\ny"
drawVerticalLine(offset, cond) =>
if cond
line.new(bar_index[offset], low-LineLength, bar_index[offset], high+LineLength,
color=color.new(color.black, 40), width=1)
// Plot Char and Lines
plotchar(Show_Days_VLines and newDay and isMon(), "Mon", "", location.bottom, color.black, size = size.tiny, text = txtMon, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isTue(), "Tue", "", location.bottom, color.black, size = size.tiny, text = txtTue, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isWed(), "Wed", "", location.bottom, color.black, size = size.tiny, text = txtWed, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isThu(), "Thu", "", location.bottom, color.black, size = size.tiny, text = txtThu, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isFri(), "Fri", "", location.bottom, color.black, size = size.tiny, text = txtFri, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isSat(), "Sat", "", location.bottom, color.black, size = size.tiny, text = txtSat, offset=2, editable=false, display=display.all - display.status_line)
plotchar(Show_Days_VLines and newDay and isSun(), "Sun", "", location.bottom, color.black, size = size.tiny, text = txtSun, offset=2, editable=false, display=display.all - display.status_line)
drawVerticalLine(0, Show_Days_VLines and newDay and isMon())
drawVerticalLine(0, Show_Days_VLines and newDay and isTue())
drawVerticalLine(0, Show_Days_VLines and newDay and isWed())
drawVerticalLine(0, Show_Days_VLines and newDay and isThu())
drawVerticalLine(0, Show_Days_VLines and newDay and isFri())
drawVerticalLine(0, Show_Days_VLines and newDay and isSat())
drawVerticalLine(0, Show_Days_VLines and newDay and isSun())
// Background Color
// trpv = 90
// bgcolor(Show_Days_Bg and bgPlot2 and isMon() ? color.new(color.red, trpv) : na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isTue() ? color.new(color.orange, trpv): na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isWed() ? color.new(color.yellow, trpv) : na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isThu() ? color.new(color.green, trpv) : na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isFri() ? color.new(color.blue, trpv) : na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isSat() ? color.new(color.purple, trpv) : na, title="Time", editable=false)
// bgcolor(Show_Days_Bg and bgPlot2 and isSun() ? color.new(color.black, trpv) : na, title="Time", editable=false)
|
RSI MTF Dashboard | https://www.tradingview.com/script/prTz5JXo-RSI-MTF-Dashboard/ | cbryce23 | https://www.tradingview.com/u/cbryce23/ | 97 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © cbryce23
//@version=5
indicator(title="RSI MTF Dashboard", shorttitle = "RSI MTF Dashboard", overlay=true)
//========== Tickers
useT1 = input(true,"", inline = "1", group="Tickers")
t1 = input.symbol("CAPITALCOM:US500","", inline = "1", group="Tickers")
useT2 = input(true,"", inline = "2", group="Tickers")
t2 = input.symbol("CAPITALCOM:US30" , "", inline = "2", group="Tickers")
useT3 = input(true,"", inline = "3", group="Tickers")
t3 = input.symbol("CAPITALCOM:US100", "", inline = "3", group="Tickers")
useT4 = input(true,"", inline = "4", group="Tickers")
t4 = input.symbol("CAPITALCOM:UK100", "", inline = "4", group="Tickers")
useT5 = input(true,"", inline = "5", group="Tickers")
t5 = input.symbol("CAPITALCOM:DE40" , "", inline = "5", group="Tickers")
useT6 = input(true,"", inline = "6", group="Tickers")
t6 = input.symbol("CAPITALCOM:EU50" , "", inline = "6", group="Tickers")
useT7 = input(true,"", inline = "7", group="Tickers")
t7 = input.symbol("CAPITALCOM:FR40" , "", inline = "7", group="Tickers")
useT8 = input(true,"", inline = "8", group="Tickers")
t8 = input.symbol("CAPITALCOM:SP35" , "", inline = "8", group="Tickers")
//========== Timeframes
TF1 = input.timeframe("15",title="TF1",group="Timeframes")
TF2 = input.timeframe("30",title="TF2",group="Timeframes")
TF3 = input.timeframe("60",title="TF3",group="Timeframes")
TF4 = input.timeframe("240",title="TF4",group="Timeframes")
TF5 = input.timeframe("D",title="TF5",group="Timeframes")
//========== RSI
rsiPeriod = input.int(title="RSI Period", defval=14, minval=2, maxval=365 , group='RSI' )
rsiBull = input.int(title="RSI Bullish", defval=65, minval=51, maxval=100, group='RSI')
rsiBear = input.int(title="RSI Bearish", defval=35, minval=0, maxval=50, group='RSI')
RSI = ta.rsi(close, rsiPeriod)
//========== Style Settings
dash_loc = input.session("Bottom Left","Dashboard Location" ,options=["Top Right","Bottom Right","Top Left","Bottom Left", "Middle Right","Bottom Center"] ,group='Style Settings')
text_size = input.session('Small',"Dashboard Size" ,options=["Tiny","Small","Normal","Large"] ,group='Style Settings')
cell_up = input(#4caf50,'Bullish Cell Color' ,group='Style Settings')
cell_dn = input(#FF5252,'Bearish Cell Color' ,group='Style Settings')
cell_neutral = input(color.gray,'Neutral Cell Color' ,group='Style Settings')
txt_col = input(color.silver,'Text/Frame Color' ,group='Style Settings')
cell_transp = input.int(25,'Cell Transparency' ,minval=0 ,maxval=100 ,group='Style Settings')
//========== RSI Values
//Ticker 1 RSI Values
t1rsi1 = request.security(t1,TF1,ta.rsi(close,rsiPeriod))
t1rsi2 = request.security(t1,TF2,ta.rsi(close,rsiPeriod))
t1rsi3 = request.security(t1,TF3,ta.rsi(close,rsiPeriod))
t1rsi4 = request.security(t1,TF4,ta.rsi(close,rsiPeriod))
t1rsi5 = request.security(t1,TF5,ta.rsi(close,rsiPeriod))
//Ticker 2 RSI Values
t2rsi1 = request.security(t2,TF1,ta.rsi(close,rsiPeriod))
t2rsi2 = request.security(t2,TF2,ta.rsi(close,rsiPeriod))
t2rsi3 = request.security(t2,TF3,ta.rsi(close,rsiPeriod))
t2rsi4 = request.security(t2,TF4,ta.rsi(close,rsiPeriod))
t2rsi5 = request.security(t2,TF5,ta.rsi(close,rsiPeriod))
//Ticker 3 RSI Values
t3rsi1 = request.security(t3,TF1,ta.rsi(close,rsiPeriod))
t3rsi2 = request.security(t3,TF2,ta.rsi(close,rsiPeriod))
t3rsi3 = request.security(t3,TF3,ta.rsi(close,rsiPeriod))
t3rsi4 = request.security(t3,TF4,ta.rsi(close,rsiPeriod))
t3rsi5 = request.security(t3,TF5,ta.rsi(close,rsiPeriod))
//Ticker 4 RSI Values
t4rsi1 = request.security(t4,TF1,ta.rsi(close,rsiPeriod))
t4rsi2 = request.security(t4,TF2,ta.rsi(close,rsiPeriod))
t4rsi3 = request.security(t4,TF3,ta.rsi(close,rsiPeriod))
t4rsi4 = request.security(t4,TF4,ta.rsi(close,rsiPeriod))
t4rsi5 = request.security(t4,TF5,ta.rsi(close,rsiPeriod))
//Ticker 5 RSI Values
t5rsi1 = request.security(t5,TF1,ta.rsi(close,rsiPeriod))
t5rsi2 = request.security(t5,TF2,ta.rsi(close,rsiPeriod))
t5rsi3 = request.security(t5,TF3,ta.rsi(close,rsiPeriod))
t5rsi4 = request.security(t5,TF4,ta.rsi(close,rsiPeriod))
t5rsi5 = request.security(t5,TF5,ta.rsi(close,rsiPeriod))
//Ticker 6 RSI Values
t6rsi1 = request.security(t6,TF1,ta.rsi(close,rsiPeriod))
t6rsi2 = request.security(t6,TF2,ta.rsi(close,rsiPeriod))
t6rsi3 = request.security(t6,TF3,ta.rsi(close,rsiPeriod))
t6rsi4 = request.security(t6,TF4,ta.rsi(close,rsiPeriod))
t6rsi5 = request.security(t6,TF5,ta.rsi(close,rsiPeriod))
//Ticker 7 RSI Values
t7rsi1 = request.security(t7,TF1,ta.rsi(close,rsiPeriod))
t7rsi2 = request.security(t7,TF2,ta.rsi(close,rsiPeriod))
t7rsi3 = request.security(t7,TF3,ta.rsi(close,rsiPeriod))
t7rsi4 = request.security(t7,TF4,ta.rsi(close,rsiPeriod))
t7rsi5 = request.security(t7,TF5,ta.rsi(close,rsiPeriod))
//Ticker 8 RSI Values
t8rsi1 = request.security(t8,TF1,ta.rsi(close,rsiPeriod))
t8rsi2 = request.security(t8,TF2,ta.rsi(close,rsiPeriod))
t8rsi3 = request.security(t8,TF3,ta.rsi(close,rsiPeriod))
t8rsi4 = request.security(t8,TF4,ta.rsi(close,rsiPeriod))
t8rsi5 = request.security(t8,TF5,ta.rsi(close,rsiPeriod))
/// -------------- Table Start -------------------
var table_position = dash_loc == 'Top Left' ? position.top_left :
dash_loc == 'Bottom Left' ? position.bottom_left :
dash_loc == 'Middle Right' ? position.middle_right :
dash_loc == 'Bottom Center' ? position.bottom_center :
dash_loc == 'Top Right' ? position.top_right : position.bottom_right
var table_text_size = text_size == 'Tiny' ? size.tiny :
text_size == 'Small' ? size.small :
text_size == 'Normal' ? size.normal : size.large
var t = table.new(table_position,8,9,
frame_color=txt_col,
frame_width=1,
border_color=txt_col,
border_width=1)
if (barstate.islast)
//headings
table.cell(t,1,0, 'Symbol' ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,0, TF1 ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,3,0, TF2 ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,4,0, TF3 ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,5,0, TF4 ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,6,0, TF5 ,text_color=color.white,text_size=table_text_size,bgcolor=color.black)
// 1
if useT1
table.cell(t,1,1, str.replace_all(t1, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,1, str.tostring(t1rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t1rsi1 >= rsiBull ? cell_up : t1rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,1, str.tostring(t1rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t1rsi2 >= rsiBull ? cell_up : t1rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,1, str.tostring(t1rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t1rsi3 >= rsiBull ? cell_up : t1rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,1, str.tostring(t1rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t1rsi4 >= rsiBull ? cell_up : t1rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,1, str.tostring(t1rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t1rsi5 >= rsiBull ? cell_up : t1rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 2
if useT2
table.cell(t,1,2, str.replace_all(t2, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,2, str.tostring(t2rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t2rsi1 >= rsiBull ? cell_up : t2rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,2, str.tostring(t2rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t2rsi2 >= rsiBull ? cell_up : t2rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,2, str.tostring(t2rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t2rsi3 >= rsiBull ? cell_up : t2rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,2, str.tostring(t2rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t2rsi4 >= rsiBull ? cell_up : t2rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,2, str.tostring(t2rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t2rsi5 >= rsiBull ? cell_up : t2rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 3
if useT3
table.cell(t,1,3, str.replace_all(t3, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,3, str.tostring(t3rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t3rsi1 >= rsiBull ? cell_up : t3rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,3, str.tostring(t3rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t3rsi2 >= rsiBull ? cell_up : t3rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,3, str.tostring(t3rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t3rsi3 >= rsiBull ? cell_up : t3rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,3, str.tostring(t3rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t3rsi4 >= rsiBull ? cell_up : t3rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,3, str.tostring(t3rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t3rsi5 >= rsiBull ? cell_up : t3rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 4
if useT4
table.cell(t,1,4, str.replace_all(t4, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,4, str.tostring(t4rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t4rsi1 >= rsiBull ? cell_up : t4rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,4, str.tostring(t4rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t4rsi2 >= rsiBull ? cell_up : t4rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,4, str.tostring(t4rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t4rsi3 >= rsiBull ? cell_up : t4rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,4, str.tostring(t4rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t4rsi4 >= rsiBull ? cell_up : t4rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,4, str.tostring(t4rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t4rsi5 >= rsiBull ? cell_up : t4rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 5
if useT5
table.cell(t,1,5, str.replace_all(t5, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,5, str.tostring(t5rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t5rsi1 >= rsiBull ? cell_up : t5rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,5, str.tostring(t5rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t5rsi2 >= rsiBull ? cell_up : t5rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,5, str.tostring(t5rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t5rsi3 >= rsiBull ? cell_up : t5rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,5, str.tostring(t5rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t5rsi4 >= rsiBull ? cell_up : t5rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,5, str.tostring(t5rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t5rsi5 >= rsiBull ? cell_up : t5rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 6
if useT6
table.cell(t,1,6, str.replace_all(t6, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,6, str.tostring(t6rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t6rsi1 >= rsiBull ? cell_up : t6rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,6, str.tostring(t6rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t6rsi2 >= rsiBull ? cell_up : t6rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,6, str.tostring(t6rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t6rsi3 >= rsiBull ? cell_up : t6rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,6, str.tostring(t6rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t6rsi4 >= rsiBull ? cell_up : t6rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,6, str.tostring(t6rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t6rsi5 >= rsiBull ? cell_up : t6rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 7
if useT7
table.cell(t,1,7, str.replace_all(t7, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,7, str.tostring(t7rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t7rsi1 >= rsiBull ? cell_up : t7rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,7, str.tostring(t7rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t7rsi2 >= rsiBull ? cell_up : t7rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,7, str.tostring(t7rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t7rsi3 >= rsiBull ? cell_up : t7rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,7, str.tostring(t7rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t7rsi4 >= rsiBull ? cell_up : t7rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,7, str.tostring(t7rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t7rsi5 >= rsiBull ? cell_up : t7rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
// 8
if useT8
table.cell(t,1,8, str.replace_all(t8, syminfo.prefix + ":", ''),text_color=color.white,text_size=table_text_size,bgcolor=color.black)
table.cell(t,2,8, str.tostring(t8rsi1, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t8rsi1 >= rsiBull ? cell_up : t8rsi1 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,3,8, str.tostring(t8rsi2, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t8rsi2 >= rsiBull ? cell_up : t8rsi2 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,4,8, str.tostring(t8rsi3, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t8rsi3 >= rsiBull ? cell_up : t8rsi3 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,5,8, str.tostring(t8rsi4, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t8rsi4 >= rsiBull ? cell_up : t8rsi4 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
table.cell(t,6,8, str.tostring(t8rsi5, '#.#'),text_color=txt_col,text_size=table_text_size, bgcolor=color.new(t8rsi5 >= rsiBull ? cell_up : t8rsi5 <= rsiBear ? cell_dn : cell_neutral,cell_transp))
|
Mervaleta Breadth | https://www.tradingview.com/script/TDEOSuXl-Mervaleta-Breadth/ | FractalTrade15 | https://www.tradingview.com/u/FractalTrade15/ | 25 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © FractalTrade15
//@version=5
indicator("Amplitud MERVAL", overlay = false, format = format.percent)
//----------------------------------------------Funciones----------------------------------------------//
f_ma(src, period, ma_type) =>
ma = ma_type == "SMA"? ta.sma(src,period) : ta.ema(src,period)
//----------------------------------------------Inputs----------------------------------------------//
len = input.int(20, title = "Periodo", group = "Inputs")
matype = input.string("SMA", title = "Tipo de Media", options = ["SMA", "EMA"], group = "Inputs")
bullc = input(color.green, title = "Color 1", group = "Colores")
bearc = input(color.red, title = "Color 2", group = "Colores")
h1 = input.int(85, title = "Banda Superior 1", group = "Bandas")
h2 = input.int(90, title = "Banda Superior 2", group = "Bandas")
l1 = input.int(15, title = "Banda Inferior 1", group = "Bandas")
l2 = input.int(10, title = "Banda Inferior 2", group = "Bandas")
//----------------------------------------------Calculos----------------------------------------------//
[ggal_usd, ggal_ma] = request.security("NASDAQ:GGAL", timeframe.period,[close, f_ma(close, len, matype)]) //traigo los valores del galicia en dolares y su media movil
ggal_ars = request.security("BCBA:GGAL", timeframe.period,close) //traigo los valores de galicia en pesos
dolar = ggal_ars/ggal_usd*10 //calculo el Dolar CCL
//traigo los valores en de los activos del merval al dolar ccl y sus respectivas medias moviles
[papel_1 , papel_1_ma ] = request.security("BCBA:YPFD", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_2 , papel_2_ma ] = request.security("BCBA:TXAR", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_3 , papel_3_ma ] = request.security("BCBA:TECO2",timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_4 , papel_4_ma ] = request.security("BCBA:PAMP", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_5 , papel_5_ma ] = request.security("BCBA:TGSU2",timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_6 , papel_6_ma ] = request.security("BCBA:BMA", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_7 , papel_7_ma ] = request.security("BCBA:BBAR", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_8 , papel_8_ma ] = request.security("BCBA:ALUA", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_9 , papel_9_ma ] = request.security("BCBA:CEPU", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_10 , papel_10_ma] = request.security("BCBA:LOMA", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_11 , papel_11_ma] = request.security("BCBA:BYMA", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_12 , papel_12_ma] = request.security("BCBA:CVH", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_13 , papel_13_ma] = request.security("BCBA:EDN", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_14 , papel_14_ma] = request.security("BCBA:CRES", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_15 , papel_15_ma] = request.security("BCBA:COME", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_16 , papel_16_ma] = request.security("BCBA:HARG", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_17 , papel_17_ma] = request.security("BCBA:TRAN", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_18 , papel_18_ma] = request.security("BCBA:SUPV", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_19 , papel_19_ma] = request.security("BCBA:MIRG", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_20 , papel_20_ma] = request.security("BCBA:VALO", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_21 , papel_21_ma] = request.security("BCBA:TGNO4",timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
[papel_22 , papel_22_ma] = request.security("BCBA:AGRO", timeframe.period,[close/dolar, f_ma(close/dolar, len, matype)])
//evaluo si cada papel esta por arriba de su media
ggal_up = ggal_usd > ggal_usd ? 1 : 0
papel_1_up = papel_1 > papel_1_ma ? 1 : 0
papel_2_up = papel_2 > papel_2_ma ? 1 : 0
papel_3_up = papel_3 > papel_3_ma ? 1 : 0
papel_4_up = papel_4 > papel_4_ma ? 1 : 0
papel_5_up = papel_5 > papel_5_ma ? 1 : 0
papel_6_up = papel_6 > papel_6_ma ? 1 : 0
papel_7_up = papel_7 > papel_7_ma ? 1 : 0
papel_8_up = papel_8 > papel_8_ma ? 1 : 0
papel_9_up = papel_9 > papel_9_ma ? 1 : 0
papel_10_up = papel_10 > papel_10_ma ? 1 : 0
papel_11_up = papel_11 > papel_11_ma ? 1 : 0
papel_12_up = papel_12 > papel_12_ma ? 1 : 0
papel_13_up = papel_13 > papel_13_ma ? 1 : 0
papel_14_up = papel_14 > papel_14_ma ? 1 : 0
papel_15_up = papel_15 > papel_15_ma ? 1 : 0
papel_16_up = papel_16 > papel_16_ma ? 1 : 0
papel_17_up = papel_17 > papel_17_ma ? 1 : 0
papel_18_up = papel_18 > papel_18_ma ? 1 : 0
papel_19_up = papel_19 > papel_19_ma ? 1 : 0
papel_20_up = papel_20 > papel_20_ma ? 1 : 0
papel_21_up = papel_21 > papel_21_ma ? 1 : 0
papel_22_up = papel_22 > papel_22_ma ? 1 : 0
//calculo la amplitud del Merval
merval_breadth = 100*math.avg(papel_1_up,papel_2_up,papel_3_up,papel_4_up,papel_5_up,papel_6_up,papel_7_up,papel_8_up,papel_9_up,papel_10_up,papel_11_up,papel_12_up,papel_13_up,papel_14_up,papel_15_up,papel_16_up,papel_17_up,papel_18_up,papel_19_up,papel_20_up,papel_21_up,papel_22_up,ggal_up)
//----------------------------------------------Graficos----------------------------------------------//
S20UpperBand1 = plot(h1, "S20 Upper Band", color=color.new(bearc,90))
S20UpperBand2 = plot(h2, "S20 Upper Band", color=color.new(bearc,90))
fill(S20UpperBand2,S20UpperBand1, h2, h1,color.new(bearc,97),color.new(bearc,80))
p50sh = plot(50, "S20 Middle Band", color=color.new(color.silver, 97), linewidth = 10)
p50 = plot(50, "S20 Middle Band", color=color.new(color.black, 50))
S20LowerBand1 = plot(l1, "S20 Lower Band", color=color.new(bullc,90))
S20LowerBand2 = plot(l2, "S20 Lower Band", color=color.new(bullc,90))
fill(S20LowerBand1,S20LowerBand2, l1,l2,color.new(bullc,80),color.new(bullc,97))
plot(merval_breadth, color = color.from_gradient(merval_breadth,l2,h2,bearc,bullc)) |
luckynickva OHLC | https://www.tradingview.com/script/cGuHmaQB-luckynickva-OHLC/ | Nickafella | https://www.tradingview.com/u/Nickafella/ | 25 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Nickafella
//@version=5
//@version=5
indicator(title="luckynickva OHLC", overlay=true, max_lines_count=500)
Open = open
High = high
Low = low
Close = close
Bar_Index = bar_index
Timeframe_1_Interval = input.timeframe(inline = "1", title = "", defval = "D")
Timeframe_1_Buy_Color = input.color( inline = "1", title = "", defval = color.black )
Timeframe_1_Sell_Color = input.color( inline = "1", title = "", defval = color.black)
Timeframe_1_Buy_Color1 = input.color( inline = "1", title = "", defval = color.black )
Timeframe_1_Sell_Color1 = input.color( inline = "1", title = "", defval = color.black)
Timeframe_1_Transparency = input.int( inline = "1", title = "", defval = 2, maxval=100, minval=1)
var float Timeframe_1_HTF_High = na
var float Timeframe_1_HTF_Low = na
var float Timeframe_1_HTF_Open = na
var int Timeframe_1_HTF_Index = na
var bool Timeframe_1_Long_Candle = false
color2 = input.color( title = "Open Line", defval = color.orange)
//New Candle
if ta.change(time(Timeframe_1_Interval)) != 0
Wick_Location = ((Timeframe_1_HTF_Index + bar_index - 1) / 2)
line.new(Timeframe_1_HTF_Index,Close[1] , Bar_Index-1 , Close[1] , color = Timeframe_1_Buy_Color, width = Timeframe_1_Transparency)
line.new(Timeframe_1_HTF_Index,Timeframe_1_HTF_Open , Bar_Index-1 , Timeframe_1_HTF_Open , color = Timeframe_1_Sell_Color, width = Timeframe_1_Transparency)
min = math.min(Close[1], Timeframe_1_HTF_Open)
max = math.max(Close[1], Timeframe_1_HTF_Open)
line.new(Wick_Location,min , Wick_Location , Timeframe_1_HTF_Low , color = Timeframe_1_Buy_Color1, width = Timeframe_1_Transparency)
line.new(Wick_Location,Timeframe_1_HTF_High , Wick_Location , max , color = Timeframe_1_Sell_Color1, width = Timeframe_1_Transparency)
Timeframe_1_HTF_Open := Open
Timeframe_1_HTF_Index := Bar_Index
Timeframe_1_HTF_High := High
Timeframe_1_HTF_Low := Low
lin2 = line.new(time,Timeframe_1_HTF_Open , time+ta.change(time(Timeframe_1_Interval)) , Timeframe_1_HTF_Open , color = color2, width = Timeframe_1_Transparency, xloc = xloc.bar_time)
line.delete(lin2[1])
else
if High > Timeframe_1_HTF_High
Timeframe_1_HTF_High := High
if Low < Timeframe_1_HTF_Low
Timeframe_1_HTF_Low := Low
long = ta.crossover(close,Timeframe_1_HTF_Open) and Timeframe_1_HTF_Open==Timeframe_1_HTF_Open[1]
short = ta.crossunder(close,Timeframe_1_HTF_Open) and Timeframe_1_HTF_Open==Timeframe_1_HTF_Open[1]
barcolor(long?color.green:short?color.red:na )
alertcondition(long or short, "Open Line Crossed") |
[MAD] Position starter & calculator | https://www.tradingview.com/script/qvCJKcW3-MAD-Position-starter-calculator/ | djmad | https://www.tradingview.com/u/djmad/ | 731 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © djmad
//@version=5
indicator(title='[MAD] Position starter & calculator', shorttitle='[MAD] Pos. S&C', overlay=true , max_boxes_count=500, max_lines_count=500, max_labels_count=500)
// load Standardparts
import djmad/Position_control/1 as POS_CON
import djmad/Mad_Standardparts/1 as STDP
//
// Variables and definitios {
var int colortheme = na
var M_Colors = matrix.new<color>(6, 10, na)
var int bartime = na
var POS_CON.t_Position_type[] myPosition = array.new<POS_CON.t_Position_type>()
var POS_CON.t_drawing_parameters myParameters = na
if bar_index == 200
bartime := STDP.f_getbartime()
//}
///////////////////// INPUTS IN TYPES /////////////////// {
if barstate.isfirst
colortheme := input.int(5, "Colortheme",minval = 0, maxval = 5, group='Colortheme (0 = Darkmode, 1 = Lightmode', tooltip='0 Darkmode, 1 Lightmode, 2 @Wotan_BitBlockArt, 3 @Linden_Blues, 4 @BitcoinFranken87')
var p_prolong_lines = input.bool(false,"Extend lines to the left", group='Colortheme (0 = Darkmode, 1 = Lightmode')
var p_showPos = input.bool(false, "Show contracts", inline="AC3", group='Leverage/Capital'),
var p_showLIQ = input.bool(false,"Show liquidation", group='Leverage/Capital')
var float SET_SL_PRICE = input.price(defval=100, title= "SL", inline="XE1", confirm = true, group='SL')
var float SET_SL_LOT = 100
var int SET_Starttime = input.time(timestamp("2020-02-19"),title= "Entry - Left limit", inline="EB1", confirm = true, group='Entrybox start'),
var float SET_Entry_Start = input.price(defval=100, title= "Entry_Boxbegin", inline="EB1", confirm = true, group='Entrybox start'),
var int SET_Stoptime = input.time(timestamp("2020-02-19"),title= "Entry - Right limit", inline="EB2", confirm = true, group='Entrybox stop'),
var float SET_Entry_Stop = input.price(defval=100, title= "Entry_Boxstop", inline="EB2", confirm = true, group='Entrybox stop'),
var float SET_Lot = input.float(1,"Contracts",minval = 0.000000000000000001, inline="AC3", group='Leverage/Capital'),
var float SET_Leverage = input.float(20,"Leverage",minval = 1,maxval = 100,step=1, inline="LE1", group='Leverage/Capital'),
var float SET_Maintenance = (100-input.float(50, "max. margin %", minval=0, maxval=100 , inline="LE1", group='Leverage/Capital',step = 1))/10000,
var float SET_TP_PRICE_1 = input.price(defval=100.0, title= "TP_1", inline="PO1", confirm = true, group='Targets')
var float SET_TP_PRICE_2 = input.price(defval=110.0, title= "TP_2", inline="PO2", confirm = true, group='Targets')
var float SET_TP_PRICE_3 = input.price(defval=120.0, title= "TP_3", inline="PO3", confirm = true, group='Targets')
var float SET_TP_PRICE_4 = input.price(defval=130.0, title= "TP_4", inline="PO4", confirm = true, group='Targets')
var float SET_TP_PRICE_5 = input.price(defval=140.0, title= "TP_5", inline="PO5", confirm = true, group='Targets')
var float SET_TP_LOT_1 = input.float(defval=20.0, title= "TP_1 %", inline="PO1", group='Targets')/100
var float SET_TP_LOT_2 = input.float(defval=20.0, title= "TP_2 %", inline="PO2", group='Targets')/100
var float SET_TP_LOT_3 = input.float(defval=20.0, title= "TP_3 %", inline="PO3", group='Targets')/100
var float SET_TP_LOT_4 = input.float(defval=20.0, title= "TP_4 %", inline="PO4", group='Targets')/100
var float SET_TP_LOT_5 = input.float(defval=20.0, title= "TP_5 %", inline="PO5", group='Targets')/100
var string pStr_fontsize = input.string(size.normal, title='Font-Size', options=[size.tiny, size.small, size.normal, size.large, size.huge], group='common')
var int pTextshift = input.int(70,"Text shifting",minval = 0,maxval = 100, inline="PP1", group='common')
var int pDecimals_price = input.int(2,"Decimals Price",minval = -3,maxval = 10, inline="PP1", group='common')
var int pDecimals_contracts = input.int(2,"Decimals Contracts",minval = -3,maxval = 10, inline="PP2", group='common')
var int pDecimals_percent = input.int(2,"Decimals Percent",minval = -3,maxval = 10, inline="PP2", group='common')
//////////////////// Input and Switch of Colors ///////////////////////
// }
///////////////////// INPUTS of colors /////////////////// {
matrix.set(M_Colors,0,0, input.color(color.rgb(255, 153, 000, 40), title= "LIQ D-T", inline="Liquidation", group='Colors'))
matrix.set(M_Colors,1,0, input.color(color.rgb(255, 153, 000, 40), title= "L-T", inline="Liquidation", group='Colors'))
matrix.set(M_Colors,0,2, input.color(color.rgb(255, 082, 082, 40), title= " SL D-T", inline="Stoploss", group='Colors'))
matrix.set(M_Colors,1,2, input.color(color.rgb(255, 082, 082, 40), title= "L-T", inline="Stoploss", group='Colors'))
matrix.set(M_Colors,0,4, input.color(color.rgb(255, 255, 255, 60), title= " Box D-T", inline="Entrybox", group='Colors'))
matrix.set(M_Colors,1,4, input.color(color.rgb(000, 000, 000, 60), title= "L-T", inline="Entrybox", group='Colors'))
matrix.set(M_Colors,0,6, input.color(color.rgb(255, 255, 255, 40), title= " TP D-T", inline="TPs", group='Colors'))
matrix.set(M_Colors,1,6, input.color(color.rgb(054, 058, 069, 40), title= "L-T", inline="TPs", group='Colors'))
matrix.set(M_Colors,0,8, input.color(color.rgb(255, 255, 255, 33), title= " Text D-T", inline="Text", group='Colors'))
matrix.set(M_Colors,1,8, input.color(color.rgb(000, 000, 000, 33), title= "L-T", inline="Text", group='Colors'))
matrix.set(M_Colors,0,1, input.color(color.rgb(255, 153, 000, 40), title= "LIQ draftline D-T", inline="Liquidation-helper", group='Colors'))
matrix.set(M_Colors,1,1, input.color(color.rgb(255, 153, 000, 40), title= "L-T", inline="Liquidation-helper", group='Colors'))
matrix.set(M_Colors,0,3, input.color(color.rgb(255, 082, 082, 40), title= " SL draftline D-T", inline="Stoploss-helper", group='Colors'))
matrix.set(M_Colors,1,3, input.color(color.rgb(255, 082, 082, 40), title= "L-T", inline="Stoploss-helper", group='Colors'))
matrix.set(M_Colors,0,5, input.color(color.rgb(035, 116, 071, 40), title= " Box draftline D-T", inline="Entrybox-helper", group='Colors'))
matrix.set(M_Colors,1,5, input.color(color.rgb(120, 134, 123, 40), title= "L-T", inline="Entrybox-helper", group='Colors'))
matrix.set(M_Colors,0,7, input.color(color.rgb(255, 255, 255, 50), title= " TP draftline D-T", inline="TPs-helper", group='Colors'))
matrix.set(M_Colors,1,7, input.color(color.rgb(054, 058, 069, 50), title= "L-T", inline="TPs-helper", group='Colors'))
//color Wotan
matrix.set(M_Colors,2,0, color.rgb(144, 026, 026, 00))
matrix.set(M_Colors,2,2, color.rgb(255, 120, 093, 40))
matrix.set(M_Colors,2,4, color.rgb(255, 161, 094, 72))
matrix.set(M_Colors,2,6, color.rgb(000, 151, 065, 40))
matrix.set(M_Colors,2,8, color.rgb(000, 192, 192, 00))
matrix.set(M_Colors,2,1, color.rgb(255, 179, 000, 60))
matrix.set(M_Colors,2,3, color.rgb(251, 075, 075, 60))
matrix.set(M_Colors,2,5, color.rgb(000, 086, 009, 60))
matrix.set(M_Colors,2,7, color.rgb(255, 255, 255, 50))
//color Lindener
matrix.set(M_Colors,3,0, color.rgb(255, 136, 000, 00))
matrix.set(M_Colors,3,2, color.rgb(237, 047, 047, 40))
matrix.set(M_Colors,3,4, color.rgb(080, 183, 078, 50))
matrix.set(M_Colors,3,6, color.rgb(060, 065, 078, 33))
matrix.set(M_Colors,3,8, color.rgb(000, 000, 000, 00))
matrix.set(M_Colors,3,1, color.rgb(255, 179, 000, 40))
matrix.set(M_Colors,3,3, color.rgb(251, 075, 075, 40))
matrix.set(M_Colors,3,5, color.rgb(064, 149, 073, 13))
matrix.set(M_Colors,3,7, color.rgb(068, 071, 083, 50))
//color Matze
matrix.set(M_Colors,4,0, color.rgb(190, 021, 021, 00))
matrix.set(M_Colors,4,2, color.rgb(234, 040, 040, 40))
matrix.set(M_Colors,4,4, color.rgb(018, 111, 205, 90))
matrix.set(M_Colors,4,6, color.rgb(000, 237, 103, 00))
matrix.set(M_Colors,4,8, color.rgb(255, 255, 255, 00))
matrix.set(M_Colors,4,1, color.rgb(255, 000, 166, 00))
matrix.set(M_Colors,4,3, color.rgb(255, 015, 015, 00))
matrix.set(M_Colors,4,5, color.rgb(064, 121, 255, 00))
matrix.set(M_Colors,4,7, color.rgb(255, 255, 255, 00))
//color Dark Light compatible
matrix.set(M_Colors,5,0, color.rgb(144, 026, 026, 20))
matrix.set(M_Colors,5,2, color.rgb(255, 120, 093, 20))
matrix.set(M_Colors,5,4, color.rgb(255, 161, 094, 80))
matrix.set(M_Colors,5,6, color.rgb(000, 151, 065, 20))
matrix.set(M_Colors,5,8, color.rgb(000, 192, 192, 20))
matrix.set(M_Colors,5,1, color.rgb(255, 179, 000, 20))
matrix.set(M_Colors,5,3, color.rgb(251, 075, 075, 20))
matrix.set(M_Colors,5,5, color.rgb(000, 086, 009, 20))
matrix.set(M_Colors,5,7, color.rgb(180, 180, 180, 20))
//select colorset
var A_Colors = matrix.row(M_Colors,colortheme)
///////////////////// }
// fill a single position with manual Data from Inputs{
myParameters := POS_CON.t_drawing_parameters.new(ShowPos = p_showPos, ShowLIQ = p_showLIQ, A_Colors = A_Colors, Prolong_lines = p_prolong_lines, Str_fontsize = pStr_fontsize, Textshift = pTextshift, Decimals_contracts = pDecimals_contracts, Decimals_price = pDecimals_price, Decimals_percent = pDecimals_percent, bartime = bartime)
var TP_Variant_type = POS_CON.t_TP_Variant.new(TP_Type = "Direct", TP_Parameter_1 = 0, TP_Parameter_2 = 0, TP_Parameter_3 = 0, TP_Parameter_4 = 0)
var TPs_array1 = array.new<POS_CON.t_TPs>(1, POS_CON.t_TPs.new(TP_Price = SET_TP_PRICE_1, TP_Lot = SET_TP_LOT_1, TP_Variant = TP_Variant_type, TP_Active = true))
var TPs_array2 = array.new<POS_CON.t_TPs>(1, POS_CON.t_TPs.new(TP_Price = SET_TP_PRICE_2, TP_Lot = SET_TP_LOT_2, TP_Variant = TP_Variant_type, TP_Active = true))
var TPs_array3 = array.new<POS_CON.t_TPs>(1, POS_CON.t_TPs.new(TP_Price = SET_TP_PRICE_3, TP_Lot = SET_TP_LOT_3, TP_Variant = TP_Variant_type, TP_Active = true))
var TPs_array4 = array.new<POS_CON.t_TPs>(1, POS_CON.t_TPs.new(TP_Price = SET_TP_PRICE_4, TP_Lot = SET_TP_LOT_4, TP_Variant = TP_Variant_type, TP_Active = true))
var TPs_array5 = array.new<POS_CON.t_TPs>(1, POS_CON.t_TPs.new(TP_Price = SET_TP_PRICE_5, TP_Lot = SET_TP_LOT_5, TP_Variant = TP_Variant_type, TP_Active = true))
var TPs_array_all = array.concat(TPs_array1,array.concat(TPs_array2,array.concat(TPs_array3,array.concat(TPs_array4,TPs_array5))))
var SLs_array1 = array.new<POS_CON.t_SLs>(1,POS_CON.t_SLs.new(SL_Price = SET_SL_PRICE, SL_Lot = na, SL_Active = na))
var SLs_array_all = SLs_array1
myPosition.unshift(
POS_CON.t_Position_type.new(Lot = SET_Lot, Leverage = SET_Leverage, Maintenance= SET_Maintenance, Starttime = SET_Starttime, Entry_Start = SET_Entry_Start, Stoptime = SET_Stoptime, Entry_Stop = SET_Entry_Stop, Entryprice = (SET_Entry_Start+SET_Entry_Stop)/2,
TPs = TPs_array_all,
SLs = SLs_array_all))
// }
///////////////////// FUNCTIONS //////////////////////// {
// Runtime {
STDP.clear_all()
if (barstate.isrealtime or barstate.islast) and myPosition.size() > 0
POS_CON.f_drawposition(_Position = myPosition, _Parameters = myParameters , _Position_index = 0)
// }
|
Advanced Trend Channel Detection (Log Scale) | https://www.tradingview.com/script/dGyhoTE5-Advanced-Trend-Channel-Detection-Log-Scale/ | Julien_Eche | https://www.tradingview.com/u/Julien_Eche/ | 129 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Julien_Eche
//@version=5
indicator("Advanced Trend Channel Detection (Log Scale)", shorttitle="ATCD Log Scale", overlay=true)
lengthInput1 = input.int(50, title="Length 1", minval = 1, maxval = 5000)
lengthInput2 = input.int(100, title="Length 2", minval = 1, maxval = 5000)
lengthInput3 = input.int(150, title="Length 3", minval = 1, maxval = 5000)
lengthInput4 = input.int(200, title="Length 4", minval = 1, maxval = 5000)
lengthInput5 = input.int(250, title="Length 5", minval = 1, maxval = 5000)
lengthInput6 = input.int(300, title="Length 6", minval = 1, maxval = 5000)
lengthInput7 = input.int(350, title="Length 7", minval = 1, maxval = 5000)
lengthInput8 = input.int(400, title="Length 8", minval = 1, maxval = 5000)
lengthInput9 = input.int(450, title="Length 9", minval = 1, maxval = 5000)
lengthInput10 = input.int(500, title="Length 10", minval = 1, maxval = 5000)
lengthInput11 = input.int(550, title="Length 11", minval = 1, maxval = 5000)
lengthInput12 = input.int(600, title="Length 12", minval = 1, maxval = 5000)
lengthInput13 = input.int(650, title="Length 13", minval = 1, maxval = 5000)
lengthInput14 = input.int(700, title="Length 14", minval = 1, maxval = 5000)
lengthInput15 = input.int(750, title="Length 15", minval = 1, maxval = 5000)
lengthInput16 = input.int(800, title="Length 16", minval = 1, maxval = 5000)
lengthInput17 = input.int(850, title="Length 17", minval = 1, maxval = 5000)
lengthInput18 = input.int(900, title="Length 18", minval = 1, maxval = 5000)
lengthInput19 = input.int(950, title="Length 19", minval = 1, maxval = 5000)
lengthInput20 = input.int(1000, title="Length 20", minval = 1, maxval = 5000)
sourceInput = input.source(close, title="Source")
group1 = "Channel Settings"
useUpperDevInput = input.bool(true, title="Upper Deviation", inline = "Upper Deviation", group = group1)
upperMultInput = input.float(2.0, title="", inline = "Upper Deviation", group = group1)
useLowerDevInput = input.bool(true, title="Lower Deviation", inline = "Lower Deviation", group = group1)
lowerMultInput = input.float(2.0, title="", inline = "Lower Deviation", group = group1)
group2 = "Display Settings"
showPearsonInput = input.bool(true, "Show Pearson's R", group = group2)
extendLeftInput = input.bool(false, "Extend Lines Left", group = group2)
extendRightInput = input.bool(true, "Extend Lines Right", group = group2)
extendStyle = switch
extendLeftInput and extendRightInput => extend.both
extendLeftInput => extend.left
extendRightInput => extend.right
=> extend.none
group3 = "Color Settings"
colorUpper = input.color(color.new(color.blue, 85), "", inline = group3, group = group3)
colorLower = input.color(color.new(color.red, 85), "", inline = group3, group = group3)
calcSlope(source, length) =>
max_bars_back(source, 5000)
if not barstate.islast or length <= 1
[float(na), float(na), float(na)]
else
sumX = 0.0
sumY = 0.0
sumXSqr = 0.0
sumXY = 0.0
for i = 0 to length - 1 by 1
val = math.log(source[i])
per = i + 1.0
sumX += per
sumY += val
sumXSqr += per * per
sumXY += val * per
slope = (length * sumXY - sumX * sumY) / (length * sumXSqr - sumX * sumX)
average = sumY / length
intercept = average - slope * sumX / length + slope
[slope, average, intercept]
calcDev(source, length, slope, average, intercept) =>
upDev = 0.0
dnDev = 0.0
stdDevAcc = 0.0
dsxx = 0.0
dsyy = 0.0
dsxy = 0.0
periods = length - 1
daY = intercept + slope * periods / 2
val = intercept
for j = 0 to periods by 1
price = math.log(high[j]) - val
if price > upDev
upDev := price
price := val - math.log(low[j])
if price > dnDev
dnDev := price
price := math.log(source[j])
dxt = price - average
dyt = val - daY
price -= val
stdDevAcc += price * price
dsxx += dxt * dxt
dsyy += dyt * dyt
dsxy += dxt * dyt
val += slope
stdDev = math.sqrt(stdDevAcc / (periods == 0 ? 1 : periods))
pearsonR = dsxx == 0 or dsyy == 0 ? 0 : dsxy / math.sqrt(dsxx * dsyy)
[stdDev, pearsonR, upDev, dnDev]
[s1, a1, i1] = calcSlope(sourceInput, lengthInput1)
[s2, a2, i2] = calcSlope(sourceInput, lengthInput2)
[s3, a3, i3] = calcSlope(sourceInput, lengthInput3)
[s4, a4, i4] = calcSlope(sourceInput, lengthInput4)
[s5, a5, i5] = calcSlope(sourceInput, lengthInput5)
[s6, a6, i6] = calcSlope(sourceInput, lengthInput6)
[s7, a7, i7] = calcSlope(sourceInput, lengthInput7)
[s8, a8, i8] = calcSlope(sourceInput, lengthInput8)
[s9, a9, i9] = calcSlope(sourceInput, lengthInput9)
[s10, a10, i10] = calcSlope(sourceInput, lengthInput10)
[s11, a11, i11] = calcSlope(sourceInput, lengthInput11)
[s12, a12, i12] = calcSlope(sourceInput, lengthInput12)
[s13, a13, i13] = calcSlope(sourceInput, lengthInput13)
[s14, a14, i14] = calcSlope(sourceInput, lengthInput14)
[s15, a15, i15] = calcSlope(sourceInput, lengthInput15)
[s16, a16, i16] = calcSlope(sourceInput, lengthInput16)
[s17, a17, i17] = calcSlope(sourceInput, lengthInput17)
[s18, a18, i18] = calcSlope(sourceInput, lengthInput18)
[s19, a19, i19] = calcSlope(sourceInput, lengthInput19)
[s20, a20, i20] = calcSlope(sourceInput, lengthInput20)
[stdDev1, pearsonR1, upDev1, dnDev1] = calcDev(sourceInput, lengthInput1, s1, a1, i1)
[stdDev2, pearsonR2, upDev2, dnDev2] = calcDev(sourceInput, lengthInput2, s2, a2, i2)
[stdDev3, pearsonR3, upDev3, dnDev3] = calcDev(sourceInput, lengthInput3, s3, a3, i3)
[stdDev4, pearsonR4, upDev4, dnDev4] = calcDev(sourceInput, lengthInput4, s4, a4, i4)
[stdDev5, pearsonR5, upDev5, dnDev5] = calcDev(sourceInput, lengthInput5, s5, a5, i5)
[stdDev6, pearsonR6, upDev6, dnDev6] = calcDev(sourceInput, lengthInput6, s6, a6, i6)
[stdDev7, pearsonR7, upDev7, dnDev7] = calcDev(sourceInput, lengthInput7, s7, a7, i7)
[stdDev8, pearsonR8, upDev8, dnDev8] = calcDev(sourceInput, lengthInput8, s8, a8, i8)
[stdDev9, pearsonR9, upDev9, dnDev9] = calcDev(sourceInput, lengthInput9, s9, a9, i9)
[stdDev10, pearsonR10, upDev10, dnDev10] = calcDev(sourceInput, lengthInput10, s10, a10, i10)
[stdDev11, pearsonR11, upDev11, dnDev11] = calcDev(sourceInput, lengthInput11, s11, a11, i11)
[stdDev12, pearsonR12, upDev12, dnDev12] = calcDev(sourceInput, lengthInput12, s12, a12, i12)
[stdDev13, pearsonR13, upDev13, dnDev13] = calcDev(sourceInput, lengthInput13, s13, a13, i13)
[stdDev14, pearsonR14, upDev14, dnDev14] = calcDev(sourceInput, lengthInput14, s14, a14, i14)
[stdDev15, pearsonR15, upDev15, dnDev15] = calcDev(sourceInput, lengthInput15, s15, a15, i15)
[stdDev16, pearsonR16, upDev16, dnDev16] = calcDev(sourceInput, lengthInput16, s16, a16, i16)
[stdDev17, pearsonR17, upDev17, dnDev17] = calcDev(sourceInput, lengthInput17, s17, a17, i17)
[stdDev18, pearsonR18, upDev18, dnDev18] = calcDev(sourceInput, lengthInput18, s18, a18, i18)
[stdDev19, pearsonR19, upDev19, dnDev19] = calcDev(sourceInput, lengthInput19, s19, a19, i19)
[stdDev20, pearsonR20, upDev20, dnDev20] = calcDev(sourceInput, lengthInput20, s20, a20, i20)
highestPearsonR = math.max(pearsonR1, pearsonR2, pearsonR3, pearsonR4, pearsonR5, pearsonR6, pearsonR7, pearsonR8, pearsonR9, pearsonR10, pearsonR11, pearsonR12, pearsonR13, pearsonR14, pearsonR15, pearsonR16, pearsonR17, pearsonR18, pearsonR19, pearsonR20)
selectedLength = highestPearsonR == pearsonR1 ? lengthInput1 : (highestPearsonR == pearsonR2 ? lengthInput2 : (highestPearsonR == pearsonR3 ? lengthInput3 : (highestPearsonR == pearsonR4 ? lengthInput4 : (highestPearsonR == pearsonR5 ? lengthInput5 : (highestPearsonR == pearsonR6 ? lengthInput6 : (highestPearsonR == pearsonR7 ? lengthInput7 : (highestPearsonR == pearsonR8 ? lengthInput8 : (highestPearsonR == pearsonR9 ? lengthInput9 : (highestPearsonR == pearsonR10 ? lengthInput10 : (highestPearsonR == pearsonR11 ? lengthInput11 : (highestPearsonR == pearsonR12 ? lengthInput12 : (highestPearsonR == pearsonR13 ? lengthInput13 : (highestPearsonR == pearsonR14 ? lengthInput14 : (highestPearsonR == pearsonR15 ? lengthInput15 : (highestPearsonR == pearsonR16 ? lengthInput16 : (highestPearsonR == pearsonR17 ? lengthInput17 : (highestPearsonR == pearsonR18 ? lengthInput18 : (highestPearsonR == pearsonR19 ? lengthInput19 : lengthInput20))))))))))))))))))
selectedS = highestPearsonR == pearsonR1 ? s1 : (highestPearsonR == pearsonR2 ? s2 : (highestPearsonR == pearsonR3 ? s3 : (highestPearsonR == pearsonR4 ? s4 : (highestPearsonR == pearsonR5 ? s5 : (highestPearsonR == pearsonR6 ? s6 : (highestPearsonR == pearsonR7 ? s7 : (highestPearsonR == pearsonR8 ? s8 : (highestPearsonR == pearsonR9 ? s9 : (highestPearsonR == pearsonR10 ? s10 : (highestPearsonR == pearsonR11 ? s11 : (highestPearsonR == pearsonR12 ? s12 : (highestPearsonR == pearsonR13 ? s13 : (highestPearsonR == pearsonR14 ? s14 : (highestPearsonR == pearsonR15 ? s15 : (highestPearsonR == pearsonR16 ? s16 : (highestPearsonR == pearsonR17 ? s17 : (highestPearsonR == pearsonR18 ? s18 : (highestPearsonR == pearsonR19 ? s19 : s20))))))))))))))))))
selectedI = highestPearsonR == pearsonR1 ? i1 : (highestPearsonR == pearsonR2 ? i2 : (highestPearsonR == pearsonR3 ? i3 : (highestPearsonR == pearsonR4 ? i4 : (highestPearsonR == pearsonR5 ? i5 : (highestPearsonR == pearsonR6 ? i6 : (highestPearsonR == pearsonR7 ? i7 : (highestPearsonR == pearsonR8 ? i8 : (highestPearsonR == pearsonR9 ? i9 : (highestPearsonR == pearsonR10 ? i10 : (highestPearsonR == pearsonR11 ? i11 : (highestPearsonR == pearsonR12 ? i12 : (highestPearsonR == pearsonR13 ? i13 : (highestPearsonR == pearsonR14 ? i14 : (highestPearsonR == pearsonR15 ? i15 : (highestPearsonR == pearsonR16 ? i16 : (highestPearsonR == pearsonR17 ? i17 : (highestPearsonR == pearsonR18 ? i18 : (highestPearsonR == pearsonR19 ? i19 : i20))))))))))))))))))
selectedStdDev = highestPearsonR == pearsonR1 ? stdDev1 : (highestPearsonR == pearsonR2 ? stdDev2 : (highestPearsonR == pearsonR3 ? stdDev3 : (highestPearsonR == pearsonR4 ? stdDev4 : (highestPearsonR == pearsonR5 ? stdDev5 : (highestPearsonR == pearsonR6 ? stdDev6 : (highestPearsonR == pearsonR7 ? stdDev7 : (highestPearsonR == pearsonR8 ? stdDev8 : (highestPearsonR == pearsonR9 ? stdDev9 : (highestPearsonR == pearsonR10 ? stdDev10 : (highestPearsonR == pearsonR11 ? stdDev11 : (highestPearsonR == pearsonR12 ? stdDev12 : (highestPearsonR == pearsonR13 ? stdDev13 : (highestPearsonR == pearsonR14 ? stdDev14 : (highestPearsonR == pearsonR15 ? stdDev15 : (highestPearsonR == pearsonR16 ? stdDev16 : (highestPearsonR == pearsonR17 ? stdDev17 : (highestPearsonR == pearsonR18 ? stdDev18 : (highestPearsonR == pearsonR19 ? stdDev19 : stdDev20))))))))))))))))))
selectedUpDev = highestPearsonR == pearsonR1 ? upDev1 : (highestPearsonR == pearsonR2 ? upDev2 : (highestPearsonR == pearsonR3 ? upDev3 : (highestPearsonR == pearsonR4 ? upDev4 : (highestPearsonR == pearsonR5 ? upDev5 : (highestPearsonR == pearsonR6 ? upDev6 : (highestPearsonR == pearsonR7 ? upDev7 : (highestPearsonR == pearsonR8 ? upDev8 : (highestPearsonR == pearsonR9 ? upDev9 : (highestPearsonR == pearsonR10 ? upDev10 : (highestPearsonR == pearsonR11 ? upDev11 : (highestPearsonR == pearsonR12 ? upDev12 : (highestPearsonR == pearsonR13 ? upDev13 : (highestPearsonR == pearsonR14 ? upDev14 : (highestPearsonR == pearsonR15 ? upDev15 : (highestPearsonR == pearsonR16 ? upDev16 : (highestPearsonR == pearsonR17 ? upDev17 : (highestPearsonR == pearsonR18 ? upDev18 : (highestPearsonR == pearsonR19 ? upDev19 : upDev20))))))))))))))))))
selectedDnDev = highestPearsonR == pearsonR1 ? dnDev1 : (highestPearsonR == pearsonR2 ? dnDev2 : (highestPearsonR == pearsonR3 ? dnDev3 : (highestPearsonR == pearsonR4 ? dnDev4 : (highestPearsonR == pearsonR5 ? dnDev5 : (highestPearsonR == pearsonR6 ? dnDev6 : (highestPearsonR == pearsonR7 ? dnDev7 : (highestPearsonR == pearsonR8 ? dnDev8 : (highestPearsonR == pearsonR9 ? dnDev9 : (highestPearsonR == pearsonR10 ? dnDev10 : (highestPearsonR == pearsonR11 ? dnDev11 : (highestPearsonR == pearsonR12 ? dnDev12 : (highestPearsonR == pearsonR13 ? dnDev13 : (highestPearsonR == pearsonR14 ? dnDev14 : (highestPearsonR == pearsonR15 ? dnDev15 : (highestPearsonR == pearsonR16 ? dnDev16 : (highestPearsonR == pearsonR17 ? dnDev17 : (highestPearsonR == pearsonR18 ? dnDev18 : (highestPearsonR == pearsonR19 ? dnDev19 : dnDev20))))))))))))))))))
startPrice = math.exp(selectedI + selectedS * (selectedLength - 1))
endPrice = math.exp(selectedI)
var line baseLine = na
if na(baseLine) and not na(startPrice)
baseLine := line.new(bar_index - selectedLength + 1, startPrice, bar_index, endPrice, width=1, extend=extendStyle, color=color.new(colorLower, 0))
else
line.set_xy1(baseLine, bar_index - selectedLength + 1, startPrice)
line.set_xy2(baseLine, bar_index, endPrice)
na
upperStartPrice = startPrice * math.exp(useUpperDevInput ? upperMultInput * selectedStdDev : selectedUpDev)
upperEndPrice = endPrice * math.exp(useUpperDevInput ? upperMultInput * selectedStdDev : selectedUpDev)
var line upper = na
lowerStartPrice = startPrice / math.exp(useLowerDevInput ? lowerMultInput * selectedStdDev : selectedDnDev)
lowerEndPrice = endPrice / math.exp(useLowerDevInput ? lowerMultInput * selectedStdDev : selectedDnDev)
var line lower = na
if na(upper) and not na(upperStartPrice)
upper := line.new(bar_index - selectedLength + 1, upperStartPrice, bar_index, upperEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(upper, bar_index - selectedLength + 1, upperStartPrice)
line.set_xy2(upper, bar_index, upperEndPrice)
na
if na(lower) and not na(lowerStartPrice)
lower := line.new(bar_index - selectedLength + 1, lowerStartPrice, bar_index, lowerEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(lower, bar_index - selectedLength + 1, lowerStartPrice)
line.set_xy2(lower, bar_index, lowerEndPrice)
na
linefill.new(upper, baseLine, color = colorUpper)
linefill.new(baseLine, lower, color = colorLower)
// Pearson's R
var label r = na
label.delete(r[1])
if showPearsonInput and not na(highestPearsonR)
r := label.new(bar_index - selectedLength + 1, lowerStartPrice, str.tostring(highestPearsonR, "#.###"), color = color.new(color.white, 100), textcolor=color.new(colorUpper, 0), size=size.normal, style=label.style_label_up)
|
ICT Macros [LuxAlgo] | https://www.tradingview.com/script/aLTywnJ0-ICT-Macros-LuxAlgo/ | LuxAlgo | https://www.tradingview.com/u/LuxAlgo/ | 2,799 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo
//@version=5
indicator('ICT Macros [LuxAlgo]', overlay = true, max_lines_count = 500, max_labels_count = 100)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
group_ln = 'London Time Settings'
lnSummerTime = input.bool(true , 'London Daylight Saving Time (DST)', group = group_ln, tooltip = 'London : Daylight Saving Time (DST)\n - DST Start : Last Sunday in March at 1:00 UTC\n - DST End : Last Sunday in October at 1:00 UTC')
group_m02 = 'London 02:33 AM 03:00 Macro'
m02330300 = input.bool(false, '02:33 AM 03:00', group = group_m02)
m02_top = input.bool(true, 'Top Line', inline = 'mc02', group = group_m02)
m02_mid = input.bool(true, 'Mid Line', inline = 'mc02', group = group_m02)
m02_bot = input.bool(true, 'Bottom Line', inline = 'mc02', group = group_m02)
m02_ext = input.bool(true, 'Extending Lines', inline = 'mc02', group = group_m02)
group_m04 = 'London 04:03 AM 04:30 Macro'
m04030430 = input.bool(false, '04:03 AM 04:30', group = group_m04)
m04_top = input.bool(true, 'Top Line', inline = 'mc04', group = group_m04)
m04_mid = input.bool(true, 'Mid Line', inline = 'mc04', group = group_m04)
m04_bot = input.bool(true, 'Bottom Line', inline = 'mc04', group = group_m04)
m04_ext = input.bool(true, 'Extending Lines', inline = 'mc04', group = group_m04)
group_ny = 'New York Time Settings'
nySummerTime = input.bool(true , 'New York Daylight Saving Time (DST)', group = group_ny, tooltip = 'New York : Daylight Saving Time (DST)\n - DST Start : Second Sunday in March at 2:00\n - DST End : First Sunday in November at 2:00')
group_m08 = 'New York 08:50 AM 09:10 Macro'
m08500910 = input.bool(false, '08:50 AM 09:10', group = group_m08)
m08_top = input.bool(true, 'Top Line', inline = 'mc08', group = group_m08)
m08_mid = input.bool(true, 'Mid Line', inline = 'mc08', group = group_m08)
m08_bot = input.bool(true, 'Bottom Line', inline = 'mc08', group = group_m08)
m08_ext = input.bool(true, 'Extending Lines', inline = 'mc08', group = group_m08)
group_m09 = 'New York 09:50 AM 10:10 Macro'
m09501010 = input.bool(true , '09:50 AM 10:10', group = group_m09)
m09_top = input.bool(true, 'Top Line', inline = 'mc09', group = group_m09)
m09_mid = input.bool(true, 'Mid Line', inline = 'mc09', group = group_m09)
m09_bot = input.bool(true, 'Bottom Line', inline = 'mc09', group = group_m09)
m09_ext = input.bool(true, 'Extending Lines', inline = 'mc09', group = group_m09)
group_m10 = 'New York 10:50 AM 11:10 Macro'
m10501110 = input.bool(true , '10:50 AM 11:10', group = group_m10)
m10_top = input.bool(true, 'Top Line', inline = 'mc10', group = group_m10)
m10_mid = input.bool(true, 'Mid Line', inline = 'mc10', group = group_m10)
m10_bot = input.bool(true, 'Bottom Line', inline = 'mc10', group = group_m10)
m10_ext = input.bool(true, 'Extending Lines', inline = 'mc10', group = group_m10)
group_m11 = 'New York 11:50 AM 12:10 Launch Macro'
m11501210 = input.bool(false, '11:50 AM 12:10', group = group_m11)
m11_top = input.bool(true, 'Top Line', inline = 'mc11', group = group_m11)
m11_mid = input.bool(true, 'Mid Line', inline = 'mc11', group = group_m11)
m11_bot = input.bool(true, 'Bottom Line', inline = 'mc11', group = group_m11)
m11_ext = input.bool(true, 'Extending Lines', inline = 'mc11', group = group_m11)
group_m13 = 'New York 13:10 PM 13:40 Macro'
m13101340 = input.bool(true , '13:10 PM 13:40', group = group_m13)
m13_top = input.bool(true, 'Top Line', inline = 'mc13', group = group_m13)
m13_mid = input.bool(true, 'Mid Line', inline = 'mc13', group = group_m13)
m13_bot = input.bool(true, 'Bottom Line', inline = 'mc13', group = group_m13)
m13_ext = input.bool(true, 'Extending Lines', inline = 'mc13', group = group_m13)
group_m15 = 'New York 15:15 PM 15:45 Macro'
m15151545 = input.bool(true , '15:15 PM 15:45', group = group_m15)
m15_top = input.bool(true, 'Top Line', inline = 'mc15', group = group_m15)
m15_mid = input.bool(true, 'Mid Line', inline = 'mc15', group = group_m15)
m15_bot = input.bool(true, 'Bottom Line', inline = 'mc15', group = group_m15)
m15_ext = input.bool(true, 'Extending Lines', inline = 'mc15', group = group_m15)
group_c = 'Macro Classification'
pLen = input.int(13, 'Length', minval = 5, maxval = 20, group = group_c)
pLoc = input.string('Body', 'Swing Area', options = ['Wick', 'Body'], group = group_c)
aColor = input.color(color.gray, 'Accumulation', group = group_c)
mColor = input.color(color.red , 'Manipulation', group = group_c)
eColor = input.color(color.blue, 'Expansion' , group = group_c)
mcText = input.string('Small', "Macro Texts", options=['Tiny', 'Small', 'Normal', 'None'])
mcSize = switch mcText
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal
=> size.tiny
mcAlert = input.bool(true, 'Alert Macro Times in Advance (Minutes)', inline = 'alert', tooltip = 'Enabling the option will plot a vertical line for the next macro time prior to the specified minutes\n\nNote: for alert configuration if not on 1 min chart please use round numbers')
mcAlertM = input.int(30, '', minval = 5, maxval = 60, step = 5, inline = 'alert')
//-----------------------------------------------------------------------------}
//UDT's
//-----------------------------------------------------------------------------{
type bar
float o = open
float h = high
float l = low
float c = close
int t = time
type macro
int t // unix time
int x2 // end bar_index
int len // macro length
float o // macro open price value
float top // macro top price value
float bottom // macro bottom price value
float mid // macro mid price value
float co // macro close open price value
float ch // macro close high price value
float cl // macro close low price value
float cc // macro close close price value
line lnh // macro top line
line lnhe // macro top line - extended
line lnl // macro bottom line
line lnle // macro bottom line - extended
line lnm // macro mid line
line lnme // macro mid line - extended
line lnf // next macro start
linefill lf // macro box (linefill)
label lb // macro label
string xloc = xloc.bar_index
color color = chart.fg_color
color nocolor = chart.bg_color
type pivotPoint
int ht // pivot high unix time
int lt // pivot low unix time
float h // last pivot high price value
float h1 // previous pivot high price value
float l // last pivot low price value
float l1 // previous pivot low price value
//-----------------------------------------------------------------------------}
//Methods / Functions
//-----------------------------------------------------------------------------{
// @function updates horizontal line's y1 and y2 value
// @param _ln (line) line to be updated
// @param _y (float) The new value
// @returns none
method set_y(line _ln, float _y) => _ln.set_y1(_y), _ln.set_y2(_y)
// @function get the current bar's unix time, hour and minute
// @param _utc (string) utc and major city in the form of '(UTC-05:00) NEW YORK'
// @param _dst (bool) daylight saving time
// @param _utcTimeOffset (array) array storing the utc info
// @param _utcCity (array) array storing the major city info
// @param _inAd (int) ofsset value in minutes
// @param _tf_m (int) timeframe multiplier
// @returns A tuple containing (int) index, (int) hour and (int) minute
method f_getBarTime(string _utc, _dst, _utcTimeOffset, _utcCity, _inAd, _tf_m) =>
utcTime = (array.get(_utcTimeOffset, array.indexof(_utcCity, _utc)) + (_dst ? 1 : 0)) * 3600000 + _inAd * 60000 + time
h = math.floor(utcTime / 3600000) % 24
m = math.floor(utcTime / 60000) % 60
int idx = 0
if _tf_m == 3
if m == 48
m := m + 2
idx := 2
else if m == 9
m := m + 1
idx := 1
//else if m == 12 or m == 42
// idx := 0
else if _tf_m == 5
if (m == 0 and h == 9) or (m == 30 and h == 7)
m := m + 3
idx := 3
[idx, h, m]
// @function calculate and get customized pivot points high low and time values
// @param _len (int) length for the pivot points high low calculation
// @param _loc (string) if set to 'wick' highest/lowest values of the detected pivot points high low will be calculated
// if set to 'Body' the highest/lowest values of the candel bodies will be returend as pivot points high low
// @returns A tuple containing (float) ph - pivot high, (float) pl - pivot low, (int) pht - pivot high unix time (int) plt - pivot low unix time
method f_getPivotPoint(int _len, _loc) =>
ph = ta.pivothigh(_len, _len)
if ph and _loc == 'Body'
ph := math.max(open[_len], close[_len])
pl = ta.pivotlow (_len, _len)
if pl and _loc == 'Body'
pl := math.min(open[_len], close[_len])
pht = ph ? time[_len] : na
plt = pl ? time[_len] : na
[ph, pl, pht, plt]
//-----------------------------------------------------------------------------}
//Main variables
//-----------------------------------------------------------------------------{
tf_m = timeframe.multiplier
bi = bar_index
var a_majorCity = array.new_string(), var a_utcTimeOffset = array.new_float(), var a_utcCity = array.new_string()
if barstate.isfirst
array.push(a_majorCity, 'NEW YORK'), array.push(a_utcTimeOffset, -5), array.push(a_utcCity, '(UTC-05:00) NEW YORK')
array.push(a_majorCity, 'LONDON' ), array.push(a_utcTimeOffset, 0 ), array.push(a_utcCity, '(UTC+00:00) LONDON' )
// Lower TF bar UDT array
ltfB = request.security_lower_tf(syminfo.tickerid, '1', bar.new())
// Lower TF pivotPoint UDT arrays
var pivotPoint p = pivotPoint.new()
[a_pH, a_pL, a_pHt, a_pLt] = request.security_lower_tf(syminfo.tickerid, '1', f_getPivotPoint(pLen, pLoc))
if not na(array.min(a_pL))
p.l := array.min(a_pL)
p.lt := array.min(a_pLt)
if not na(array.max(a_pH))
p.h := array.max(a_pH)
p.ht := array.max(a_pHt)
//-----------------------------------------------------------------------------}
//Detect ICT macros
//-----------------------------------------------------------------------------{
var macro mc = macro.new()
// @function main function : detects macros, draws nad controls macro components and classifies macros
// @param _m (bool) enable/disable specific macro
// @param _msh (int) macro start hour
// @param _msm (int) macro start minute
// @param _mh (bool) macro top line control option
// @param _ml (bool) macro bottom line control option
// @param _mm (bool) macro middle line control option
// @param _me (bool) macro extended lines control option
// @param _mt (bool) macro label text value
//
// @param _utc (string) utc and major city in the form of '(UTC-05:00) NEW YORK'
// @param _dst (bool) daylight saving time
// @param _tf_m (int) timeframe multiplier
// @param _alert (bool) next macro time start location, displays in _alertM minutes
// @param _alertM (int) alert in _alertM minutes
// @returns macro UDT components created
processMacro(_m, _msh, _msm, _mh, _ml, _mm, _me, _mt, _utc, _dst, _tf_m, _alert, _alertM) =>
if _m
[_, ha, ma] = f_getBarTime(_utc, _dst, a_utcTimeOffset, a_utcCity, _alertM, _tf_m)
if ha == _msh and ma == _msm
alert(_mt + ' macro will be in play in ' + str.tostring(_alertM) + ' minutes for instrument ' + syminfo.ticker)
if _alert
mc.lnf := line.new(time + _alertM * 60000 , high, time + _alertM * 60000, low, xloc.bar_time, extend.both, mc.color, line.style_solid , 1)
[idx, h, m] = f_getBarTime(_utc, _dst, a_utcTimeOffset, a_utcCity, 0, _tf_m)
if h == 8 or h == 9 or h == 10 or h == 11
if m == 3
mc.len := 27
else
mc.len := 20
else if h == 7
mc.len := 27
else
mc.len := 30
if h == _msh and m == _msm
mc.lnf.delete()
if ltfB.size() > idx
if not na(ltfB.get(idx).h)
mc.t := ltfB.get(idx).t
mc.o := ltfB.get(idx).o
mc.top := ltfB.get(idx).h
mc.bottom := ltfB.get(idx).l
if idx == 0
mc.x2 := bi + math.round(mc.len / _tf_m)
else
mc.x2 := bi + math.round(mc.len / _tf_m) + 1
mc.lnh := line.new(bi, mc.top, int(mc.x2), mc.top, color = _mh ? mc.color : mc.nocolor, style = line.style_solid , width = 2)
mc.lnhe := line.new(int(mc.x2), mc.top, int(mc.x2), mc.top, color = _me ? _mh ? mc.color : mc.nocolor : mc.nocolor, style = line.style_dotted, width = 2)
mc.lnl := line.new(bi, mc.bottom, int(mc.x2), mc.bottom, color =_ml ? mc.color : mc.nocolor, style = line.style_solid , width = 2)
mc.lnle := line.new(int(mc.x2), mc.bottom, int(mc.x2), mc.bottom, color = _me ? _ml ? mc.color : mc.nocolor : mc.nocolor, style = line.style_dotted, width = 2)
mc.lnm := line.new(bi, math.avg(mc.top, mc.bottom), int(mc.x2), math.avg(mc.top, mc.bottom), color = _mm ? mc.color : mc.nocolor, style = line.style_dotted, width = 1)
mc.lnme := line.new(bi, math.avg(mc.top, mc.bottom), int(mc.x2), math.avg(mc.top, mc.bottom), color = _me ? _mm ? mc.color : mc.nocolor : mc.nocolor, style = line.style_dotted, width = 1)
mc.lf := linefill.new(mc.lnh, mc.lnl, color.new(color.gray, 100))
mc.lb := label.new(bi + int(mc.len / _tf_m / 2), mc.top, mcText != 'None' ? 'MACRO\n' + _mt : '', xloc.bar_index, yloc.price, #00000000, label.style_label_down, chart.fg_color, mcSize, text.align_left, '')
p.l1 := p.l
p.h1 := p.h
else if bi < int(mc.x2) and time >= mc.t
mc.top := math.max(high, mc.lnh.get_y1())
mc.lnh.set_y(mc.top), mc.lnhe.set_y(mc.top)
mc.bottom := math.min(low , mc.lnl.get_y1())
mc.lnl.set_y(mc.bottom), mc.lnle.set_y(mc.bottom)
mc.mid := math.avg(math.max(high, mc.lnh.get_y1()), math.min(low , mc.lnl.get_y1()))
mc.lnm.set_y(mc.mid), mc.lnme.set_y(mc.mid)
mc.lb.set_y(math.max(high, mc.lb.get_y()))
if not na(array.min(a_pL)) and p.lt < mc.t
p.l1 := array.min(a_pL)
if not na(array.max(a_pH)) and p.ht < mc.t
p.h1 := array.max(a_pH)
else if bi == int(mc.x2)
if ltfB.size() > idx
if not na(ltfB.get(idx).c)
mc.co := ltfB.get(idx).o
mc.ch := ltfB.get(idx).h
mc.cl := ltfB.get(idx).l
mc.cc := ltfB.get(idx).c
mc.top := math.max(mc.ch, mc.lnh.get_y1())
mc.lnh.set_y(mc.top), mc.lnhe.set_y(mc.top)
mc.bottom := math.min(mc.cl , mc.lnl.get_y1())
mc.lnl.set_y(mc.bottom), mc.lnle.set_y(mc.bottom)
mc.mid := math.avg(math.max(mc.top, mc.lnh.get_y1()), math.min(mc.bottom , mc.lnl.get_y1()))
mc.lnm.set_y(mc.mid), mc.lnme.set_y(mc.mid)
mc.lb.set_y(math.max(mc.top, mc.lb.get_y()))
if not na(array.min(a_pL)) and p.lt < mc.t
p.l1 := array.min(a_pL)
if not na(array.max(a_pH)) and p.ht < mc.t
p.h1 := array.max(a_pH)
else if mc.t == mc.t[1]
mc.lnhe.set_x2(bi), mc.lnle.set_x2(bi), mc.lnme.set_x2(bi)
if bi == int(mc.x2) + 1 and not str.contains(mc.lb.get_text(), 'on MACRO')
mc.lb.set_tooltip('mc open : '+ str.tostring(mc.o , format.mintick) +
'\nmc close : ' + str.tostring(mc.cc , format.mintick) +
'\nmc top : ' + str.tostring(mc.top , format.mintick) +
'\nmc mid : ' + str.tostring(mc.mid , format.mintick) +
'\nmc bottom : ' + str.tostring(mc.bottom, format.mintick) )
if mc.bottom < p.l1 and mc.top > p.h1
if (mc.o < math.avg(mc.bottom, mc.mid) and mc.cc > math.avg(mc.top, mc.mid)) or (mc.o > math.avg(mc.top, mc.mid) and mc.cc < math.avg(mc.bottom, mc.mid))
mc.lf.set_color(color.new(eColor, 73))
if mcText != 'None'
mc.lb.set_text('Expansion ' + mc.lb.get_text())
else
mc.lf.set_color(color.new(mColor, 73))
if mcText != 'None'
mc.lb.set_text('Manipulation ' + mc.lb.get_text())
else if mc.bottom < p.l1 or mc.top > p.h1
if (mc.co > mc.mid and mc.cc < mc.mid) or (mc.co < mc.mid and mc.cc > mc.mid) or (mc.o < mc.mid and mc.cc < mc.mid) or (mc.o > mc.mid and mc.cc > mc.mid) // pL > pmcPL or pmcPH < pH
mc.lf.set_color(color.new(aColor, 73))
if mcText != 'None'
mc.lb.set_text('Accumulation ' + mc.lb.get_text())
else
mc.lf.set_color(color.new(eColor, 73))
if mcText != 'None'
mc.lb.set_text('Expansion ' + mc.lb.get_text())
else
if p.l == p.l1 and p.h == p.h1 and (mc.o < math.avg(mc.bottom, mc.mid) and mc.cc > math.avg(mc.top, mc.mid)) or (mc.o > math.avg(mc.top, mc.mid) and mc.cc < math.avg(mc.bottom, mc.mid))
mc.lf.set_color(color.new(eColor, 73))
if mcText != 'None'
mc.lb.set_text('Expansion ' + mc.lb.get_text())
else
mc.lf.set_color(color.new(aColor, 73))
if mcText != 'None'
mc.lb.set_text('Accumulation ' + mc.lb.get_text())
//-----------------------------------------------------------------------------}
//Process macros
//-----------------------------------------------------------------------------{
if tf_m <= 5
processMacro(m02330300, 7, 33, m02_top, m02_bot, m02_mid, m02_ext, '02:33 AM - 03:00', '(UTC+00:00) LONDON' , lnSummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m04030430, 9, 3, m04_top, m04_bot, m04_mid, m04_ext, '04:03 AM - 04:30', '(UTC+00:00) LONDON' , lnSummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m08500910, 8, 50, m08_top, m08_bot, m08_mid, m08_ext, '08:50 AM - 09:10', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m09501010, 9, 50, m09_top, m09_bot, m09_mid, m09_ext, '09:50 AM - 10:10', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m10501110, 10, 50, m10_top, m10_bot, m10_mid, m10_ext, '10:50 AM - 11:10', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m11501210, 11, 50, m11_top, m11_bot, m11_mid, m11_ext, '11:50 AM - 12:10', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m13101340, 13, 10, m13_top, m13_bot, m13_mid, m13_ext, '01:10 PM - 01:40', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
processMacro(m15151545, 15, 15, m15_top, m15_bot, m15_mid, m15_ext, '03:15 PM - 03:45', '(UTC-05:00) NEW YORK', nySummerTime, tf_m, mcAlert, mcAlertM)
else
var table note = table.new(position.bottom_right, 1, 1)
if barstate.islast
table.cell(note, 0, 0, 'ICT Macros are supported on:\n 1 min, 3 mins and 5 mins charts\n\n', text_size=size.small, text_color=chart.fg_color)
//-----------------------------------------------------------------------------} |
Pattern Forecast (Expo) | https://www.tradingview.com/script/YVjt2ruq-Pattern-Forecast-Expo/ | Zeiierman | https://www.tradingview.com/u/Zeiierman/ | 973 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Zeiierman
//@version=5
indicator("Pattern Forecast (Expo)",overlay=true,max_bars_back=5000,max_boxes_count=500,max_lines_count=500)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Tooltips {
string t1 = "The amount of Forecast candles that should be displayed in the future."
string t2 = "Background color divider between price and forecast."
string t3 = "Displays the current event found"
string t4 = "Forecast placement"
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Inputs {
pattern = input.string("Doji","Pattern",["OnNeckBearish",
"RisingWindowBullish",
"FallingWindowBearish",
"FallingThreeMethodsBullish",
"FallingThreeMethodsBearish",
"TweezerBottomBullish",
"TweezerTopBearish",
"DarkCloudCoverBearish",
"UpsideTasukiGapBullish",
"DownsideTasukiGapBearish",
"EveningDojiStarBearish",
"Doji",
"DojiStarBullish",
"DojiStarBearish",
"MorningDojiStarBullish",
"PiercingBullish",
"HammerBullish",
"HangingManBearish",
"ShootingStarBearish",
"InvertedHammerBullish",
"MorningStarBullish",
"EveningStarBearish",
"MarubozuWhiteBullish",
"MarubozuBlackBearish",
"GravestoneDojiBearish",
"DragonflyDojiBullish",
"HaramiCrossBullish",
"HaramiCrossBearish",
"HaramiBullish",
"HaramiBearish",
"LongLowerShadowBullish",
"LongUpperShadowBearish",
"SpinningTopWhite",
"SpinningTopBlack",
"ThreeWhiteSoldiersBullish",
"ThreeBlackCrowsBearish",
"EngulfingBullish",
"EngulfingBearish",
"AbandonedBabyBullish",
"AbandonedBabyBearish",
"TriStarBullish",
"TriStarBearish",
"KickingBullish",
"KickingBearish"])
Forecast = input.int(50,"Event Candles",1,158,tooltip=t1)
Divider = input.bool(true,"Event Divider",t2)
Display = input.bool(true,"Display Event",t3)
Placement = input.int(5,"Placement",1,25,tooltip=t4)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Types {
type Event
box currentEvent
box pastEvent
box prediction
array<box> candle
array<line> wick
type Data
array<int> b
array<int> d
array<float> o
array<float> h
array<float> l
array<float> c
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Variables & Arrays {
b = bar_index
var data = Data.new(array.new<int>(),
array.new<int>(),
array.new<float>(),
array.new<float>(),
array.new<float>(),
array.new<float>())
var event = Event.new(box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dotted,
bgcolor=color.new(color.teal,75)),
array.new<box>(Forecast),
array.new<line>(Forecast))
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Methods {
method Pattern(Data x,i)=>
//Get Candles
o0 = x.o.get(i)
h0 = x.h.get(i)
l0 = x.l.get(i)
c0 = x.c.get(i)
o1 = x.o.get(i+1)
h1 = x.h.get(i+1)
l1 = x.l.get(i+1)
c1 = x.c.get(i+1)
o2 = x.o.get(i+2)
h2 = x.h.get(i+2)
l2 = x.l.get(i+2)
c2 = x.c.get(i+2)
o3 = x.o.get(i+3)
h3 = x.h.get(i+3)
l3 = x.l.get(i+3)
c3 = x.c.get(i+3)
o4 = x.o.get(i+4)
h4 = x.h.get(i+4)
l4 = x.l.get(i+4)
c4 = x.c.get(i+4)
o5 = x.o.get(i+5)
h5 = x.h.get(i+5)
l5 = x.l.get(i+5)
c5 = x.c.get(i+5)
o6 = x.o.get(i+6)
h6 = x.h.get(i+6)
l6 = x.l.get(i+6)
c6 = x.c.get(i+6)
o7 = x.o.get(i+7)
h7 = x.h.get(i+7)
l7 = x.l.get(i+7)
c7 = x.c.get(i+7)
o8 = x.o.get(i+8)
h8 = x.h.get(i+8)
l8 = x.l.get(i+8)
c8 = x.c.get(i+8)
//Candle Calculation
C_BodyHi = math.max(c0,o0)
C_BodyLo = math.min(c0,o0)
C_BodyHi1 = math.max(c1,o1)
C_BodyLo1 = math.min(c1,o1)
C_BodyHi2 = math.max(c2,o1)
C_BodyLo2 = math.min(c2,o2)
C_BodyHi3 = math.max(c3,o3)
C_BodyLo3 = math.min(c3,o3)
C_BodyHi4 = math.max(c4,o4)
C_BodyLo4 = math.min(c4,o4)
C_Body = C_BodyHi - C_BodyLo
C_Body1 = C_BodyHi1 - C_BodyLo1
C_Body2 = C_BodyHi2 - C_BodyLo2
C_Body3 = C_BodyHi3 - C_BodyLo3
C_Body4 = C_BodyHi4 - C_BodyLo4
C_BodyAvg = math.avg(math.abs(o0-c0),math.abs(o1-c1),math.abs(o2-c2),math.abs(o3-c3),math.abs(o4-c4))
C_BodyAvg1 = math.avg(math.abs(o1-c1),math.abs(o2-c2),math.abs(o3-c3),math.abs(o4-c4),math.abs(o5-c5))
C_BodyAvg2 = math.avg(math.abs(o2-c2),math.abs(o3-c3),math.abs(o4-c4),math.abs(o5-c5),math.abs(o6-c6))
C_BodyAvg3 = math.avg(math.abs(o3-c3),math.abs(o4-c4),math.abs(o5-c5),math.abs(o6-c6),math.abs(o7-c7))
C_BodyAvg4 = math.avg(math.abs(o4-c4),math.abs(o5-c5),math.abs(o6-c6),math.abs(o7-c7),math.abs(o8-c8))
C_SmallBody = C_Body < C_BodyAvg
C_SmallBody1 = C_Body1 < C_BodyAvg1
C_SmallBody2 = C_Body2 < C_BodyAvg2
C_SmallBody3 = C_Body3 < C_BodyAvg3
C_SmallBody4 = C_Body4 < C_BodyAvg4
C_LongBody = C_Body > C_BodyAvg
C_LongBody1 = C_Body1 > C_BodyAvg1
C_LongBody2 = C_Body2 > C_BodyAvg2
C_LongBody3 = C_Body3 > C_BodyAvg3
C_LongBody4 = C_Body4 > C_BodyAvg4
C_UpShadow = h0 - C_BodyHi
C_UpShadow1 = h1 - C_BodyHi1
C_UpShadow2 = h2 - C_BodyHi2
C_DnShadow = C_BodyLo - l0
C_DnShadow1 = C_BodyLo1 - l1
C_DnShadow2 = C_BodyLo2 - l2
C_HasUpShadow = C_UpShadow > 5.0 / 100 * C_Body
C_HasDnShadow = C_DnShadow > 5.0 / 100 * C_Body
C_WhiteBody = o0 < c0
C_WhiteBody1 = o1 < c1
C_WhiteBody2 = o2 < c2
C_WhiteBody3 = o3 < c3
C_WhiteBody4 = o4 < c4
C_BlackBody = o0 > c0
C_BlackBody1 = o1 > c1
C_BlackBody2 = o2 > c2
C_BlackBody3 = o3 > c3
C_BlackBody4 = o4 > c4
C_Range = h0-l0
C_Range1 = h1-l1
C_Range2 = h2-l2
C_IsInsideBar = C_BodyHi1 > C_BodyHi and C_BodyLo1 < C_BodyLo
C_BodyMiddle = C_Body / 2 + C_BodyLo
C_BodyMiddle1 = C_Body1 / 2 + C_BodyLo1
C_BodyMiddle2 = C_Body2 / 2 + C_BodyLo2
C_ShadowEquals = C_UpShadow == C_DnShadow or (math.abs(C_UpShadow - C_DnShadow) / C_DnShadow * 100) < 100.0 and (math.abs(C_DnShadow - C_UpShadow) / C_UpShadow * 100) < 100.0
C_ShadowEquals1 = C_UpShadow1 == C_DnShadow1 or (math.abs(C_UpShadow1 - C_DnShadow1) / C_DnShadow1 * 100) < 100.0 and (math.abs(C_DnShadow1 - C_UpShadow1) / C_UpShadow1 * 100) < 100.0
C_ShadowEquals2 = C_UpShadow2 == C_DnShadow2 or (math.abs(C_UpShadow2 - C_DnShadow2) / C_DnShadow2 * 100) < 100.0 and (math.abs(C_DnShadow2 - C_UpShadow2) / C_UpShadow2 * 100) < 100.0
C_IsDojiBody = C_Range > 0 and C_Body <= C_Range * 5.0 / 100
C_IsDojiBody1 = C_Range1 > 0 and C_Body1 <= C_Range1 * 5.0 / 100
C_IsDojiBody2 = C_Range2 > 0 and C_Body2 <= C_Range2 * 5.0 / 100
C_Doji = C_IsDojiBody and C_ShadowEquals
C_Doji1 = C_IsDojiBody1 and C_ShadowEquals1
C_Doji2 = C_IsDojiBody2 and C_ShadowEquals2
C_3WSld_HaveNotUpShadow = C_Range * 5.0 / 100 > C_UpShadow
C_3WSld_HaveNotUpShadow1 = C_Range1 * 5.0 / 100 > C_UpShadow1
C_3WSld_HaveNotUpShadow2 = C_Range2 * 5.0 / 100 > C_UpShadow2
C_3BCrw_HaveNotDnShadow = C_Range * 5.0 / 100 > C_DnShadow
C_3BCrw_HaveNotDnShadow1 = C_Range1 * 5.0 / 100 > C_DnShadow1
C_3BCrw_HaveNotDnShadow2 = C_Range2 * 5.0 / 100 > C_DnShadow2
C_BodyGapUpBullish = C_BodyHi1 < C_BodyLo
C_BodyGapDnBullish = C_BodyLo1 > C_BodyHi
C_BodyGapDnBullish1 = C_BodyLo2 > C_BodyHi1
C_BodyGapUp = C_BodyHi1 < C_BodyLo
C_BodyGapUp1 = C_BodyHi2 < C_BodyLo1
C_BodyGapDn = C_BodyLo1 > C_BodyHi
C_Marubozu = C_LongBody and C_UpShadow <= 5.0/100*C_Body and C_DnShadow <= 5.0/100*C_Body
C_Marubozu1 = C_LongBody1 and C_UpShadow1 <= 5.0/100*C_Body1 and C_DnShadow1 <= 5.0/100*C_Body1
C_MarubozuBlackBullish = C_Marubozu and C_BlackBody
C_MarubozuBlackBullish1 = C_Marubozu1 and C_BlackBody1
C_MarubozuBearishKicking = C_LongBody and C_UpShadow <= 5.0/100*C_Body and C_DnShadow <= 5.0/100*C_Body
C_MarubozuBearishKicking1 = C_LongBody1 and C_UpShadow1 <= 5.0/100*C_Body1 and C_DnShadow1 <= 5.0/100*C_Body1
C_MarubozuWhiteBearish = C_MarubozuBearishKicking and C_WhiteBody
C_MarubozuWhiteBearish1 = C_MarubozuBearishKicking1 and C_WhiteBody1
//Switch Function
output = switch pattern
"OnNeckBearish" => C_BlackBody1 and C_LongBody1 and C_WhiteBody and o0 < c1 and C_SmallBody and C_Range!=0 and math.abs(c0-l1)<=C_BodyAvg*0.05
"RisingWindowBullish" => (C_Range!=0 and C_Range1!=0) and l0 > h1
"FallingWindowBearish" => (C_Range!=0 and C_Range1!=0) and h0 < l1
"FallingThreeMethodsBullish" => (C_LongBody4 and C_WhiteBody4) and (C_SmallBody3 and C_BlackBody3 and o3<h4 and c3>l4) and (C_SmallBody2 and C_BlackBody2 and o2<h4 and c2>l4) and (C_SmallBody1 and C_BlackBody1 and o1<h4 and c1>l4) and (C_LongBody and C_WhiteBody and c0>c4)
"FallingThreeMethodsBearish" => (C_LongBody4 and C_BlackBody4) and (C_SmallBody3 and C_WhiteBody3 and o3>l4 and c3<h4) and (C_SmallBody2 and C_WhiteBody2 and o2>l4 and c2<h4) and (C_SmallBody1 and C_WhiteBody1 and o1>l4 and c1<h4) and (C_LongBody and C_BlackBody and c0<c4)
"TweezerBottomBullish" => (not C_IsDojiBody or (C_HasUpShadow and C_HasDnShadow)) and math.abs(l0-l1) <= C_BodyAvg*0.05 and C_BlackBody1 and C_WhiteBody and C_LongBody1
"TweezerTopBearish" => (not C_IsDojiBody or (C_HasUpShadow and C_HasDnShadow)) and math.abs(h0-h1) <= C_BodyAvg*0.05 and C_WhiteBody1 and C_BlackBody and C_LongBody1
"DarkCloudCoverBearish" => (C_WhiteBody1 and C_LongBody1) and (C_BlackBody and o0 >= h1 and c0 < C_BodyMiddle1 and c0 > o1)
"UpsideTasukiGapBullish" => C_SmallBody1 and C_WhiteBody2 and C_BodyLo1 > C_BodyHi2 and C_WhiteBody1 and C_BlackBody and C_BodyLo >= C_BodyHi2 and C_BodyLo <= C_BodyLo1
"DownsideTasukiGapBearish" => C_SmallBody1 and C_BlackBody2 and C_BodyHi1 < C_BodyLo2 and C_BlackBody1 and C_WhiteBody and C_BodyHi <= C_BodyLo2 and C_BodyHi >= C_BodyHi1
"EveningDojiStarBearish" => C_LongBody2 and C_IsDojiBody1 and C_LongBody and C_WhiteBody2 and C_BodyLo1 > C_BodyHi2 and C_BlackBody and C_BodyLo <= C_BodyMiddle2 and C_BodyLo > C_BodyLo2 and C_BodyLo1 > C_BodyHi
"Doji" => C_Doji
"DojiStarBullish" => C_BlackBody1 and C_LongBody1 and C_IsDojiBody and C_BodyHi < C_BodyLo1
"DojiStarBearish" => C_WhiteBody1 and C_LongBody1 and C_IsDojiBody and C_BodyLo > C_BodyHi1
"MorningDojiStarBullish" => C_LongBody2 and C_IsDojiBody1 and C_LongBody and C_BlackBody2 and C_BodyHi1 < C_BodyLo2 and C_WhiteBody and C_BodyHi >= C_BodyMiddle2 and C_BodyHi < C_BodyHi2 and C_BodyHi1 < C_BodyLo
"PiercingBullish" => (C_BlackBody1 and C_LongBody1) and (C_WhiteBody and o0 <= l1 and c0 > C_BodyMiddle1 and c0 < o1)
"HammerBullish" => C_SmallBody and C_Body > 0 and C_BodyLo > (h0+l0)/2 and C_DnShadow >= 2.0 * C_Body and not C_HasUpShadow
"HangingManBearish" => C_SmallBody and C_Body > 0 and C_BodyLo > (h0+l0)/2 and C_DnShadow >= 2.0 * C_Body and not C_HasUpShadow
"ShootingStarBearish" => C_SmallBody and C_Body > 0 and C_BodyHi < (h0+l0)/2 and C_UpShadow >= 2.0 * C_Body and not C_HasDnShadow
"InvertedHammerBullish" => C_SmallBody and C_Body > 0 and C_BodyHi < (h0+l0)/2 and C_UpShadow >= 2.0 * C_Body and not C_HasDnShadow
"MorningStarBullish" => C_LongBody2 and C_SmallBody1 and C_LongBody and C_BlackBody2 and C_BodyHi1 < C_BodyLo2 and C_WhiteBody and C_BodyHi >= C_BodyMiddle2 and C_BodyHi < C_BodyHi2 and C_BodyHi1 < C_BodyLo
"EveningStarBearish" => C_LongBody2 and C_SmallBody1 and C_LongBody and C_WhiteBody2 and C_BodyLo1 > C_BodyHi2 and C_BlackBody and C_BodyLo <= C_BodyMiddle2 and C_BodyLo > C_BodyLo2 and C_BodyLo1 > C_BodyHi
"MarubozuWhiteBullish" => C_WhiteBody and C_LongBody and C_UpShadow <= 5.0/100*C_Body and C_DnShadow <= 5.0/100*C_Body and C_WhiteBody
"MarubozuBlackBearish" => C_BlackBody and C_LongBody and C_UpShadow <= 5.0/100*C_Body and C_DnShadow <= 5.0/100*C_Body and C_BlackBody
"GravestoneDojiBearish" => C_IsDojiBody and C_DnShadow <= C_Body
"DragonflyDojiBullish" => C_IsDojiBody and C_UpShadow <= C_Body
"HaramiCrossBullish" => C_LongBody1 and C_BlackBody1 and C_IsDojiBody and h0 <= C_BodyHi1 and l0 >= C_BodyLo1
"HaramiCrossBearish" => C_LongBody1 and C_WhiteBody1 and C_IsDojiBody and h0 <= C_BodyHi1 and l0 >= C_BodyLo1
"HaramiBullish" => C_LongBody1 and C_BlackBody1 and C_WhiteBody and C_SmallBody and h0 <= C_BodyHi1 and l0 >= C_BodyLo1
"HaramiBearish" => C_LongBody1 and C_WhiteBody1 and C_BlackBody and C_SmallBody and h0 <= C_BodyHi1 and l0 >= C_BodyLo1
"LongLowerShadowBullish" => C_DnShadow > C_Range/100*75.0
"LongUpperShadowBearish" => C_UpShadow > C_Range/100*75.0
"SpinningTopWhite" => C_DnShadow >= C_Range / 100 * 34.0 and C_UpShadow >= C_Range / 100 * 34.0 and not C_IsDojiBody and C_WhiteBody
"SpinningTopBlack" => C_DnShadow >= C_Range / 100 * 34.0 and C_UpShadow >= C_Range / 100 * 34.0 and not C_IsDojiBody and C_BlackBody
"ThreeWhiteSoldiersBullish" => C_LongBody and C_LongBody1 and C_LongBody2 and C_WhiteBody and C_WhiteBody1 and C_WhiteBody2 and c0 > c1 and c1 > c2 and o0 < c1 and o0 > o1 and o1 < c2 and o1 > o2 and C_3WSld_HaveNotUpShadow and C_3WSld_HaveNotUpShadow1 and C_3WSld_HaveNotUpShadow2
"ThreeBlackCrowsBearish" => C_LongBody and C_LongBody1 and C_LongBody2 and C_BlackBody and C_BlackBody1 and C_BlackBody2 and c0 < c1 and c1 < c2 and o0 > c1 and o0 < o1 and o1 > c2 and o1 < o2 and C_3BCrw_HaveNotDnShadow and C_3BCrw_HaveNotDnShadow1 and C_3BCrw_HaveNotDnShadow2
"EngulfingBullish" => C_WhiteBody and C_LongBody and C_BlackBody1 and C_SmallBody1 and c0 >= o1 and o0 <= c1 and ( c0 > o1 or o0 < c1 )
"EngulfingBearish" => C_BlackBody and C_LongBody and C_WhiteBody1 and C_SmallBody1 and c0 <= o1 and o0 >= c1 and ( c0 < o1 or o0 > c1 )
"AbandonedBabyBullish" => C_BlackBody2 and C_IsDojiBody1 and l2 > h1 and C_WhiteBody and h1 < l0
"AbandonedBabyBearish" => C_WhiteBody2 and C_IsDojiBody1 and h2 < l1 and C_BlackBody and l1 > h0
"TriStarBullish" => C_Doji2 and C_Doji1 and C_Doji and C_BodyGapDnBullish1 and C_BodyGapUpBullish
"TriStarBearish" => C_Doji2 and C_Doji1 and C_Doji and C_BodyGapUp1 and C_BodyGapDn
"KickingBullish" => C_MarubozuBlackBullish1 and C_Marubozu and C_WhiteBody and h1 < l0
"KickingBearish" => C_MarubozuWhiteBearish1 and C_MarubozuBearishKicking and C_BlackBody and l1 > h0
//Store Data
method Store(Data x)=>
int B = b
int bin = close>open?1:close<open?-1:0
float O = open
float H = high
float L = low
float C = close
x.b.unshift(B)
x.d.unshift(bin)
x.o.unshift(O)
x.h.unshift(H)
x.l.unshift(L)
x.c.unshift(C)
//Candle Plots
method Candle(Event e,x,i)=>
int dist = Placement
float prev = x.c.get(i)
float diff = ((close-prev)/prev)+1
for j=i-1 to i-Forecast
idx = j-i+Forecast
if j<0
break
else
pos = x.d.get(j)
top = (pos>0?x.c.get(j):x.o.get(j))*diff
bot = (pos>0?x.o.get(j):x.c.get(j))*diff
hi = (x.h.get(j))*diff
lo = (x.l.get(j))*diff
col = pos==1?#26a69a:pos==-1?#ef5350:chart.fg_color
candle = e.candle.get(idx)
if na(candle)
e.candle.set(idx,box.new(b+dist,top,b+dist+2,bot,na,bgcolor=col))
e.wick.set(idx,line.new(b+dist+1,hi,b+dist+1,lo,color=col))
else
box.set_lefttop(e.candle.get(idx),b+dist,top)
box.set_rightbottom(e.candle.get(idx),b+dist+2,bot)
box.set_bgcolor(e.candle.get(idx),col)
line.set_xy1(e.wick.get(idx),b+dist+1,hi)
line.set_xy2(e.wick.get(idx),b+dist+1,lo)
line.set_color(e.wick.get(idx),col)
dist += 3
//Events Display
method Events(Event e,idx,h1,l1,h2,l2,fh,fl)=>
int end = idx
e.pastEvent.set_lefttop(end,h2)
e.pastEvent.set_rightbottom(end,l2)
e.prediction.set_lefttop(end+1,fh.max())
e.prediction.set_rightbottom(math.min(b,end+Forecast),fl.min())
//Current Event
method Series(Data x)=>
data.Store()
bool found = false
if barstate.islast
for i=1 to x.d.size()-9
search = x.Pattern(i)
if search
found := true
event.Candle(data,i)
if Display
bar = x.b.get(i)
h1 = x.h.get(i)
l1 = x.l.get(i)
h2 = x.h.get(i)
l2 = x.l.get(i)
fh = i-Forecast<=0?x.h.slice(0,i-1):x.h.slice(i-Forecast,i-1)
fl = i-Forecast<=0?x.l.slice(0,i-1):x.l.slice(i-Forecast,i-1)
event.Events(bar,h1,l1,h2,l2,fh,fl)
label.new(x.b.get(i),x.h.get(i))
break
if barstate.islast and not found
runtime.error("Sorry I couldn't find that specific pattern, try another one :)")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Divider {
bgcolor(Divider and barstate.islast?color.new(chart.fg_color,90):na,1)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Run Code {
data.Series()
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
|
Chickenz Compare performance of 2 Tickers (Default - BTC/LTC) | https://www.tradingview.com/script/gYImuE7r-Chickenz-Compare-performance-of-2-Tickers-Default-BTC-LTC/ | iancarmichael71 | https://www.tradingview.com/u/iancarmichael71/ | 6 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © iancarmichael71
//@version=5
indicator("Chickenz BTC/LTC", overlay=false)
ticker1 = input.symbol("LTCUSDT")
LTC_close = request.security(ticker1,"",close)
LTC = request.security(syminfo.tickerid,"",close)
LTChigh = ta.highest(LTC_close, length = 100)
LTCLow = ta.lowest(LTC_close, length = 100)
LTCScore = ((LTC_close - LTCLow) / (LTChigh-LTCLow))
ticker2 = input.symbol("BTCUSDT")
BTC_close = request.security(ticker2,"",close)
BTC = request.security(syminfo.tickerid,"",close)
BTChigh = ta.highest(BTC_close, length = 50)
BTCLow = ta.lowest(BTC_close, length = 50)
BTCScore = ((BTC_close - BTCLow) / (BTChigh-BTCLow))
BTCLTC = BTC_close / LTC_close
plot(LTCScore, color=color.red, title="Ticker1")
plot(BTCScore,color = color.white, title="Ticker2")
//plot(BTC_close, color = color.red)
//plot(LTC_close, color = color.blue)
|
Vector2DrawQuad | https://www.tradingview.com/script/aTm4QVKx-Vector2DrawQuad/ | RicardoSantos | https://www.tradingview.com/u/RicardoSantos/ | 14 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RicardoSantos
//@version=5
// @description functions to handle vector2 Quad drawing operations.
library(title='Vector2DrawQuad')
// .
// references:
// https://docs.unity3d.com/ScriptReference/Vector2.html
// https://gist.github.com/winduptoy/a1aa09c3499e09edbd33
// https://github.com/dogancoruh/Javascript-Vector2/blob/master/js/vector2.js
// https://gist.github.com/Dalimil/3daf2a0c531d7d030deb37a7bfeff454
// https://gist.github.com/jeantimex/7fa22744e0c45e5df770b532f696af2d
// https://gist.github.com/volkansalma/2972237
// .
//#region ~~~ Imports:
import RicardoSantos/CommonTypesMath/1 as TMath
import RicardoSantos/CommonTypesDrawing/1 as TDraw
import RicardoSantos/Vector2/1 as Vector2
import RicardoSantos/Vector2DrawLine/1 as line
//#endregion
//#region -> Constructor:
// new () {
// @function Draws a quadrilateral with background fill.
// @param a v2 . Vector2 object, in the form `(x, y)`.
// @param b v2 . Vector2 object, in the form `(x, y)`.
// @param c v2 . Vector2 object, in the form `(x, y)`.
// @param d v2 . Vector2 object, in the form `(x, y)`.
// @param xloc string . Type of axis unit, bar_index or time.
// @param bg_color color . Color of the background.
// @param line_color color . Color of the line.
// @param line_style string . Style of the line.
// @param line_width int . Width of the line.
// @returns Quad object.
export new (
TMath.Vector2 a ,
TMath.Vector2 b ,
TMath.Vector2 c ,
TMath.Vector2 d ,
string xloc = 'bi' ,
color bg_color = #2196f3,
color line_color = #2196f3,
string line_style = 'sol' ,
int line_width = 1 ) =>
TMath.Segment2 _ab = TMath.Segment2.new(a, b)
TMath.Segment2 _bc = TMath.Segment2.new(b, c)
TMath.Segment2 _cd = TMath.Segment2.new(d, c) // the origin/target are inverted because of the fill
TMath.Segment2 _da = TMath.Segment2.new(d, a)
line _line1 = line.new(_ab, xloc, extend.none, line_color, line_style, line_width)
line _line2 = line.new(_bc, xloc, extend.none, line_color, line_style, line_width)
line _line3 = line.new(_cd, xloc, extend.none, line_color, line_style, line_width)
line _line4 = line.new(_da, xloc, extend.none, line_color, line_style, line_width)
linefill _fill = linefill.new(_line1, _line3, bg_color)
TDraw.Quad.new(_line1, _line2, _line3, _line4, _fill)
// TEST: 20230220 RS
// if barstate.islast
// _qa = Vector2.new(bar_index + 0.0, 0.0)
// _qb = Vector2.new(bar_index + 0.0, 100.0)
// _qc = Vector2.new(bar_index + 100.0, 100.0)
// _qd = Vector2.new(bar_index + 100.0, 0.0)
// new(_qa, _qb, _qc, _qd)
// }
// copy () {
// @function Copy a existing quad object.
// @param this Quad . Source quad.
// @returns Quad.
export method copy (TDraw.Quad this) =>
TDraw.Quad.copy(this)
// }
// delete () {
// @function Delete all the underlying object properties (line, fill).
// @param this `Quad` Source triangle.
// @returns `void`.
export method delete (TDraw.Quad this) =>
this.ab.delete()
this.bc.delete()
this.cd.delete()
this.da.delete()
this.fill.delete()
// }
//#endregion
//#region -> Properties:
// set_position_a () {
// @function Set the position of corner `a` (modifies source quad).
// @param this Quad . Source quad.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Quad.
export method set_position_a (TDraw.Quad this, int x, float y) =>
this.ab.set_xy1(x, y)
this.da.set_xy2(x, y)
this
// @function Set the position of corner `a` (modifies source quad).
// @param this Quad . Source quad.
// @param position Vector2 . New position.
// @returns Source Quad.
export method set_position_a (TDraw.Quad this, TMath.Vector2 position) =>
this.ab.set_xy1(int(position.x), position.y)
this.da.set_xy2(int(position.x), position.y)
this
// }
// set_position_b () {
// @function Set the position of corner `b` (modifies source quad).
// @param this Quad . Source quad.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Quad.
export method set_position_b (TDraw.Quad this, int x, float y) =>
this.ab.set_xy2(x, y)
this.bc.set_xy1(x, y)
this
// @function Set the position of corner `b` (modifies source quad).
// @param this Quad . Source quad.
// @param position Vector2 . New position.
// @returns Source Quad.
export method set_position_b (TDraw.Quad this, TMath.Vector2 position) =>
this.ab.set_xy2(int(position.x), position.y)
this.bc.set_xy1(int(position.x), position.y)
this
// }
// set_position_c () {
// @function Set the position of corner `c` (modifies source quad).
// @param this Quad . Source quad.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Quad.
export method set_position_c (TDraw.Quad this, int x, float y) =>
this.bc.set_xy2(x, y)
this.cd.set_xy2(x, y) // the origin/target are inverted because of the fill
this
// @function Set the position of corner `c` (modifies source quad).
// @param this Quad . Source quad.
// @param position Vector2 . New position.
// @returns Source Quad.
export method set_position_c (TDraw.Quad this, TMath.Vector2 position) =>
this.bc.set_xy2(int(position.x), position.y)
this.cd.set_xy2(int(position.x), position.y) // the origin/target are inverted because of the fill
this
// }
// set_position_d () {
// @function Set the position of corner `d` (modifies source quad).
// @param this Quad . Source quad.
// @param x int . Value at the x axis.
// @param y float . Value at the y axis.
// @returns Source Quad.
export method set_position_d (TDraw.Quad this, int x, float y) =>
this.cd.set_xy1(x, y) // the origin/target are inverted because of the fill
this.da.set_xy1(x, y)
this
// @function Set the position of corner `d` (modifies source quad).
// @param this Quad . Source quad.
// @param position Vector2 . New position.
// @returns Source Quad.
export method set_position_d (TDraw.Quad this, TMath.Vector2 position) =>
this.cd.set_xy1(int(position.x), position.y) // the origin/target are inverted because of the fill
this.da.set_xy1(int(position.x), position.y)
this
// TEST: 20230220 RS
// if barstate.islast
// _qa = Vector2.new(bar_index + 0.0, 0.0)
// _qb = Vector2.new(bar_index + 0.0, 100.0)
// _qc = Vector2.new(bar_index + 100.0, 100.0)
// _qd = Vector2.new(bar_index + 100.0, 0.0)
// _q = new(_qa, _qb, _qc, _qd)
// _q.set_position_a(bar_index+10, 10.0)
// _q.set_position_b(bar_index+110, 120.0)
// _q.set_position_c(bar_index+210, 110.0)
// _q.set_position_d(bar_index+210, 50.0)
// }
// set_line_style () {
// @function Update quad style options (modifies Source quad).
// @param this Quad . Source quad.
// @param bg_color color . Color of the background.
// @param line_color color . Color of the line.
// @param line_style string . Style of the line.
// @param line_width int . Width of the line.
// @returns Source Quad.
export method set_style (
TDraw.Quad this ,
color bg_color = #2196f3,
color line_color = #2196f3,
string line_style = 'sol' ,
int line_width = 1 ) =>
linefill.set_color(this.fill, bg_color)
this.ab.set_color(line_color) , this.ab.set_width(line_width) , this.ab.set_style(line_style)
this.bc.set_color(line_color) , this.bc.set_width(line_width) , this.bc.set_style(line_style)
this.cd.set_color(line_color) , this.cd.set_width(line_width) , this.cd.set_style(line_style)
this.da.set_color(line_color) , this.da.set_width(line_width) , this.da.set_style(line_style)
this
// TEST: 20230218 RS
// qstyle = input.string('sol', options=[line.style_solid, line.style_dashed, line.style_dotted])
// qlinecol = input.color(#e3e3e3)
// qbgcol = input.color(#e3e3e3)
// qlinew = input.int(1)
// if barstate.islast
// _qa = Vector2.new(bar_index + 0.0, 0.0)
// _qb = Vector2.new(bar_index + 100.0, 50.0)
// _qc = Vector2.new(bar_index + 200.0, 50.0)
// _qd = Vector2.new(bar_index + 100.0, 0.0)
// _q = new(_qa, _qb, _qc, _qd)
// _q.set_style(qbgcol, qlinecol, qstyle, qlinew)
// }
// set_bg_color () {
// @function Update quad style options (modifies Source quad).
// @param this Quad . Source quad.
// @param bg_color color . Color of the background.
// @returns Source Quad.
export method set_bg_color (
TDraw.Quad this ,
color bg_color = #2196f3) =>
linefill.set_color(this.fill, bg_color)
this
// }
// set_line_color () {
// @function Update quad style options (modifies Source quad).
// @param this Quad . Source quad.
// @param line_color color . Color of the line.
// @returns Source Quad.
export method set_line_color (
TDraw.Quad this ,
color line_color = #2196f3) =>
this.ab.set_color(line_color)
this.bc.set_color(line_color)
this.cd.set_color(line_color)
this.da.set_color(line_color)
this
// }
// set_line_style () {
// @function Update quad style options (modifies Source quad).
// @param this Quad . Source quad.
// @param line_style string . Style of the line.
// @returns Source Quad.
export method set_line_style (
TDraw.Quad this ,
string line_style = 'sol' ) =>
this.ab.set_style(line_style)
this.bc.set_style(line_style)
this.cd.set_style(line_style)
this.da.set_style(line_style)
this
// }
// set_line_width () {
// @function Update quad style options (modifies Source quad).
// @param this Quad . Source quad.
// @param line_width int . Width of the line.
// @returns Source Quad.
export method set_line_width (
TDraw.Quad this ,
int line_width = 1 ) =>
this.ab.set_width(line_width)
this.bc.set_width(line_width)
this.cd.set_width(line_width)
this.da.set_width(line_width)
this
// }
//#endregion
//#region -> Instance Methods:
// move () {
// @function Move quad by provided amount (modifies source quad).
// @param this Quad . Source quad.
// @param x float . Amount to move the vertices of the quad in the x axis.
// @param y float . Amount to move the vertices of the quad in the y axis.
// @returns Source Quad.
export method move (TDraw.Quad this, int x=0, float y=0.0) =>
int _ax = this.ab.get_x1() , float _ay = this.ab.get_y1()
int _bx = this.bc.get_x1() , float _by = this.bc.get_y1()
int _cx = this.cd.get_x2() , float _cy = this.cd.get_y2() // the origin/target are inverted because of the fill
int _dx = this.da.get_x1() , float _dy = this.da.get_y1()
this.ab.set_xy1(_ax + x, _ay + y) , this.ab.set_xy2(_bx + x, _by + y)
this.bc.set_xy1(_bx + x, _by + y) , this.bc.set_xy2(_cx + x, _cy + y)
this.cd.set_xy2(_cx + x, _cy + y) , this.cd.set_xy1(_dx + x, _dy + y) // the origin/target are inverted because of the fill
this.da.set_xy1(_dx + x, _dy + y) , this.da.set_xy2(_ax + x, _ay + y)
this
// @function Move quad by provided amount (modifies source quad).
// @param this Quad . Source quad.
// @param amount Vector2 . Amount to move the vertices of the quad in the x and y axis.
// @returns Source Quad.
export method move (TDraw.Quad this, TMath.Vector2 amount) =>
this.move(int(amount.x), amount.y)
// TEST: 20230218 RS
// mx = input.int(0, step=10)
// my = input.float(0.0, step=10.0)
// if barstate.islast
// _qa = Vector2.new(bar_index + 0.0, 0.0)
// _qb = Vector2.new(bar_index + 100.0, 50.0)
// _qc = Vector2.new(bar_index + 200.0, 50.0)
// _qd = Vector2.new(bar_index + 150.0, 20.0)
// _q = new(_qa, _qb, _qc, _qd)
// _q.move(mx, my)
// }
// rotate_around () {
// @function Rotate source quad around a center (modifies source quad).
// @param this Quad . Source quad.
// @param center Vector2 . Center coordinates of the rotation.
// @param angle float . Value of angle in degrees.
// @returns Source Quad.
export method rotate_around (TDraw.Quad this, TMath.Vector2 center, float angle) =>
int _ax = this.ab.get_x1() , float _ay = this.ab.get_y1()
int _bx = this.bc.get_x1() , float _by = this.bc.get_y1()
int _cx = this.cd.get_x2() , float _cy = this.cd.get_y2() // the origin/target are inverted because of the fill
int _dx = this.cd.get_x1() , float _dy = this.cd.get_y1()
_a = Vector2.new(_ax, _ay).rotate_around(center, angle)
_b = Vector2.new(_bx, _by).rotate_around(center, angle)
_c = Vector2.new(_cx, _cy).rotate_around(center, angle)
_d = Vector2.new(_dx, _dy).rotate_around(center, angle)
this.ab.set_xy1(int(_a.x), _a.y) , this.ab.set_xy2(int(_b.x), _b.y)
this.bc.set_xy1(int(_b.x), _b.y) , this.bc.set_xy2(int(_c.x), _c.y)
this.cd.set_xy2(int(_c.x), _c.y) , this.cd.set_xy1(int(_d.x), _d.y) // the origin/target are inverted because of the fill
this.da.set_xy1(int(_d.x), _d.y) , this.da.set_xy2(int(_a.x), _a.y)
this
// @function Rotate source quad around a center (modifies source quad).
// @param this Quad . Source quad.
// @param center_x int . Center coordinates of the rotation.
// @param center_y float . Center coordinates of the rotation.
// @param angle float . Value of angle in degrees.
// @returns Source Quad.
export method rotate_around (TDraw.Quad this, int center_x, float center_y, float angle) =>
this.rotate_around(Vector2.new(center_x, center_y), angle)
// TEST: 20230218 RS
// mx = input.int(50, step=10)
// my = input.float(50.0, step=10.0)
// degree = input.float(0.0, step=10.0)
// if barstate.islast
// _qa = Vector2.new(bar_index + 0.0, 0.0)
// _qb = Vector2.new(bar_index + 100.0, 50.0)
// _qc = Vector2.new(bar_index + 200.0, 50.0)
// _qd = Vector2.new(bar_index + 150.0, 20.0)
// _center = Vector2.new(bar_index + mx, my)
// _q = new(_qa, _qb, _qc, _qd)
// _q.rotate_around(_center, degree)
// }
//#endregion |
Open Interest All Exchanges | https://www.tradingview.com/script/0jFP2swS-Open-Interest-All-Exchanges/ | JanLosev | https://www.tradingview.com/u/JanLosev/ | 161 | study | 5 | MPL-2.0 | // This high code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// ©JanLosev
// I am happy and make the people around me happier.
// With Love JanLosev.
// @version=5
indicator(title='Open Interest', shorttitle='OI', overlay=false, precision=0)
OPEN_BITFINEX = request.security('BITFINEX:BTCUSDLONGS',"", open) + request.security('BITFINEX:BTCUSDSHORTS',"", open) + request.security('BITFINEX:BTCUSTLONGS',"", open) + request.security('BITFINEX:BTCUSTLONGS',"", open)
CLOSE_BITFINEX = request.security('BITFINEX:BTCUSDLONGS',"", close) + request.security('BITFINEX:BTCUSDSHORTS',"", close) + request.security('BITFINEX:BTCUSTLONGS',"", close) + request.security('BITFINEX:BTCUSTLONGS',"", close)
HIGH_BITFINEX = request.security('BITFINEX:BTCUSDLONGS',"", high) + request.security('BITFINEX:BTCUSDSHORTS',"", high) + request.security('BITFINEX:BTCUSTLONGS',"", high) + request.security('BITFINEX:BTCUSTLONGS',"", high)
LOW_BITFINEX = request.security('BITFINEX:BTCUSDLONGS',"", low) + request.security('BITFINEX:BTCUSDSHORTS',"", low) + request.security('BITFINEX:BTCUSTLONGS',"", low) + request.security('BITFINEX:BTCUSTLONGS',"", low)
OPEN_BINANCE = request.security('BINANCE:BTCUSDTPERP_OI',"", open)
CLOSE_BINANCE = request.security('BINANCE:BTCUSDTPERP_OI',"", close)
HIGH_BINANCE = request.security('BINANCE:BTCUSDTPERP_OI',"", high)
LOW_BINANCE = request.security('BINANCE:BTCUSDTPERP_OI',"", low)
OPEN_KRAKEN = request.security('KRAKEN:BTCUSDPERP_OI',"", open) / request.security('KRAKEN:BTCUSDPERP',"", open)
CLOSE_KRAKEN = request.security('KRAKEN:BTCUSDPERP_OI',"", close) / request.security('KRAKEN:BTCUSDPERP',"", close)
HIGH_KRAKEN = request.security('KRAKEN:BTCUSDPERP_OI',"", high) / request.security('KRAKEN:BTCUSDPERP',"", high)
LOW_KRAKEN = request.security('KRAKEN:BTCUSDPERP_OI',"", low) / request.security('KRAKEN:BTCUSDPERP',"", low)
OPEN_BITMEX = request.security('BITMEX:XBTUSD_OI',"", open) / request.security('BITMEX:XBTUSD.P',"", open) + request.security('BITMEX:XBTUSDT_OI',"", open) / request.security('BITMEX:XBTUSDT.P',"", open)
CLOSE_BITMEX = request.security('BITMEX:XBTUSD_OI',"", close) / request.security('BITMEX:XBTUSD.P',"", close) + request.security('BITMEX:XBTUSDT_OI',"", close) / request.security('BITMEX:XBTUSDT.P',"", close)
HIGH_BITMEX = request.security('BITMEX:XBTUSD_OI',"", high) / request.security('BITMEX:XBTUSD.P',"", high) + request.security('BITMEX:XBTUSDT_OI',"", high) / request.security('BITMEX:XBTUSDT.P',"", high)
LOW_BITMEX = request.security('BITMEX:XBTUSD_OI',"", low) / request.security('BITMEX:XBTUSD.P',"", low) + request.security('BITMEX:XBTUSDT_OI',"", low) / request.security('BITMEX:XBTUSDT.P',"", low)
Open = (na(OPEN_BITFINEX) ? 0 : OPEN_BITFINEX) + (na(OPEN_BINANCE) ? 0 : OPEN_BINANCE) + (na(OPEN_KRAKEN) ? 0 : OPEN_KRAKEN) + (na(OPEN_BITMEX) ? 0 : OPEN_BITMEX)
Close = (na(CLOSE_BITFINEX) ? 0 : CLOSE_BITFINEX) + (na(CLOSE_BINANCE) ? 0 : CLOSE_BINANCE) + (na(CLOSE_KRAKEN) ? 0 : CLOSE_KRAKEN) + (na(CLOSE_BITMEX) ? 0 : CLOSE_BITMEX)
High = (na(HIGH_BITFINEX) ? 0 : HIGH_BITFINEX) + (na(HIGH_BINANCE) ? 0 : HIGH_BINANCE) + (na(HIGH_KRAKEN) ? 0 : HIGH_KRAKEN) + (na(HIGH_BITMEX) ? 0 : HIGH_BITMEX)
Low = (na(LOW_BITFINEX) ? 0 : LOW_BITFINEX) + (na(LOW_BINANCE) ? 0 : LOW_BINANCE) + (na(LOW_KRAKEN) ? 0 : LOW_KRAKEN) + (na(LOW_BITMEX) ? 0 : LOW_BITMEX)
plotcandle(Open, High, Low, Close, color = Open < Close ? color.new(#2962ff, 50) : color.new(#5d606b, 50), wickcolor = Open < Close ? color.new(#2962ff, 10) : color.new(#5d606b, 10), bordercolor = Open < Close ? color.new(#2962ff, 10) : color.new(#5d606b, 10), title = 'Open Interest') |
Absolute Momentum Intensity | https://www.tradingview.com/script/WJXmIX3B-Absolute-Momentum-Intensity/ | ALifeToMake | https://www.tradingview.com/u/ALifeToMake/ | 101 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ALifeToMake
//@version=5
indicator(title="Absolute Momentum Intensity V1.2", shorttitle="AMI", overlay=false)
// AMI ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
bullColor=input.color(color.new(#22ab94, 0), title="Bullish")
bearColor=input.color(color.new(#f7525f, 0), title="Bearish")
contrast = input.int(100, minval = 1, title = "Contrast", tooltip="Can be used to increase or decrease the difference between high and low momentum. A value of 20 will show every single impulse, while 100 will flatten them, thus revealing when the momentum is the strongest.")
MAoneLength = input.int(5, minval = 1, title = "Length of the moving average", group = "First ribbon", tooltip="This line serves as threshold between bullish and bearish for AMI.")
MAoneColor = input.color(color.new(#787b86, 0), title = "Line", group = "First ribbon")
BullOneBGColor=input.color(color.new(#42bda8, 0), title="Bullish bg", group="First ribbon", tooltip="Background (bg) color.")
BearOneBGColor=input.color(color.new(#f77c80, 0), title="Bearish bg", group="First ribbon")
decreaseOneBGColor=input.color(color.new(#9598a1, 0), title="Decreasing momentum bg", group="First ribbon")
MAtwoLength = input.int(10, minval = 1, title = "Length of the moving average", group = "Second ribbon")
MAtwoColor = input.color(color.new(#1e1e1e, 100), title = "Line", group = "Second ribbon")
BullTwoBGColor=input.color(color.new(#70ccbd, 0), title="Bullish bg", group = "Second ribbon")
BearTwoBGColor=input.color(color.new(#faa1a4, 0), title="Bearish bg", group = "Second ribbon")
decreaseTwoBGColor=input.color(color.new(#b2b5be, 0), title="Decreasing momentum bg", group = "Second ribbon")
MAthreeLength = input.int(15, minval = 1, title = "Length of the moving average", group = "Third ribbon")
MAthreeColor = input.color(color.new(#1e1e1e, 100), title = "Line", group = "Third ribbon")
BullThreeBGColor=input.color(color.new(#ace5dc, 0), title="Bullish bg", group = "Third ribbon")
BearThreeBGColor=input.color(color.new(#fccbcd, 0), title="Bearish bg", group = "Third ribbon")
decreaseThreeBGColor=input.color(color.new(#d1d4dc, 0), title="Decreasing momentum bg", group = "Third ribbon")
// Calculations -----------------------------------------------------------------------------------------
body = open<close ? close-open : open-close
var momentumVal=0.0
float volumeMA = ta.sma(volume, contrast)
float ampMA = ta.sma(body, contrast)
float myVolumeMA = (volume/volumeMA)+1
float myAmpMA = (body/ampMA)+1
float momentum = myVolumeMA*myAmpMA
// If no data is available
var bool naCounter = true
if na(momentum) and naCounter
label.new(bar_index,0,"Insufficient datas to calculate AMI", color = #787b86, textcolor = #000000, style = label.style_label_down)
naCounter := false
// If datas are available
orientedMomentum = open<close ? momentum : -momentum
momentumVal := momentumVal[1]? momentumVal[1]+orientedMomentum : momentum
MAmoOne = ta.rma(momentumVal,MAoneLength)
MAmoTwo = ta.rma(momentumVal,MAtwoLength)
MAmoThree = ta.rma(momentumVal,MAthreeLength)
inBetween = momentumVal > MAmoOne ? momentumVal-MAmoOne : momentumVal < MAmoOne ? MAmoOne-momentumVal : momentumVal
inBetweenPast=inBetween*0.8
// Plots ------------------------------------------------------------------------------------------------
moColor = momentumVal >= MAmoOne ? bullColor : bearColor
siPlotThree=plot(MAmoThree, color=MAthreeColor, linewidth = 1)
siPlotTwo=plot(MAmoTwo, color=MAtwoColor, linewidth = 1)
siPlotOne=plot(MAmoOne, color=MAoneColor, linewidth = 1)
moPlot=plot(momentumVal, color=moColor, linewidth = 2)
isCrossOver = ta.crossover(momentumVal,MAmoOne)
isCrossUnder = ta.crossunder(momentumVal,MAmoOne)
bullBearOneBGColor = momentumVal >= MAmoOne and inBetween>=inBetweenPast[1]? BullOneBGColor : momentumVal >= MAmoOne and inBetween<inBetweenPast[1]? decreaseOneBGColor : momentumVal <= MAmoOne and inBetween>=inBetweenPast[1]? BearOneBGColor : momentumVal <= MAmoOne and inBetween<inBetweenPast[1]? decreaseOneBGColor : isCrossOver ? BullOneBGColor : isCrossUnder ? BearOneBGColor : decreaseOneBGColor
bullBearTwoBGColor = momentumVal >= MAmoOne and inBetween>=inBetweenPast[1]? BullTwoBGColor : momentumVal >= MAmoOne and inBetween<inBetweenPast[1]? decreaseTwoBGColor : momentumVal <= MAmoOne and inBetween>=inBetweenPast[1]? BearTwoBGColor : momentumVal <= MAmoOne and inBetween<inBetweenPast[1]? decreaseTwoBGColor : isCrossOver ? BullTwoBGColor : isCrossUnder ? BearTwoBGColor : decreaseTwoBGColor
bullBearThreeBGColor = momentumVal >= MAmoOne and inBetween>=inBetweenPast[1]? BullThreeBGColor : momentumVal >= MAmoOne and inBetween<inBetweenPast[1]? decreaseThreeBGColor : momentumVal <= MAmoOne and inBetween>=inBetweenPast[1]? BearThreeBGColor : momentumVal <= MAmoOne and inBetween<inBetweenPast[1]? decreaseThreeBGColor : isCrossOver ? BullThreeBGColor : isCrossUnder ? BearThreeBGColor : decreaseThreeBGColor
fill(siPlotTwo, siPlotThree, color=bullBearThreeBGColor)
fill(siPlotOne, siPlotTwo, color=bullBearTwoBGColor)
fill(moPlot, siPlotOne, color=bullBearOneBGColor)
// DIVERGENCES -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
bullDivColor=input.color(color.new(#22ab94, 40), title="Bullish", group = "Divergences")
bearDivColor=input.color(color.new(#f7525f, 40), title="Bearish", group = "Divergences")
pivotsRight = input(title='Right search length', defval=10, group = "Divergences")
pivotsLeft = input(title='Left search length', defval=10, group = "Divergences")
minRange = input(title='Smallest area of search', defval=5, group = "Divergences")
maxRange = input(title='Largest area of search', defval=60, group = "Divergences")
// Calculations -----------------------------------------------------------------------------------------
isPivotLow = na(ta.pivotlow(momentumVal, pivotsLeft, pivotsRight)) ? false : true
isPivotHigh = na(ta.pivothigh(momentumVal, pivotsLeft, pivotsRight)) ? false : true
distance(myPivot) =>
bars = ta.barssince(myPivot == true)
minRange <= bars and bars <= maxRange
isIndiePivotLow = momentumVal[pivotsRight] > ta.valuewhen(isPivotLow, momentumVal[pivotsRight], 1) and distance(isPivotLow[1])
isChartPivotLow = low[pivotsRight] < ta.valuewhen(isPivotLow, low[pivotsRight], 1)
isIndiePivotHigh = momentumVal[pivotsRight] < ta.valuewhen(isPivotHigh, momentumVal[pivotsRight], 1) and distance(isPivotHigh[1])
isChartPivotHigh = high[pivotsRight] > ta.valuewhen(isPivotHigh, high[pivotsRight], 1)
bullishDivergence = isChartPivotLow and isIndiePivotLow and isPivotLow
bearishDivergence = isChartPivotHigh and isIndiePivotHigh and isPivotHigh
// Plots ------------------------------------------------------------------------------------------------
bullActivDivColor=bullishDivergence ? bullDivColor : color.new(#ffffff, 100)
bearActivDivColor=bearishDivergence ? bearDivColor : color.new(#ffffff, 100)
plotBullDiv = isPivotLow ? momentumVal[pivotsRight] : na
plotBearDiv = isPivotHigh ? momentumVal[pivotsRight] : na
plot(plotBullDiv, offset=-pivotsRight, linewidth=1, color=bullActivDivColor)
plot(plotBearDiv, offset=-pivotsRight, linewidth=1, color=bearActivDivColor)
|
PSESS1 - Learn PineScript Inputs | https://www.tradingview.com/script/mEPAmXNT-PSESS1-Learn-PineScript-Inputs/ | Mahdi_Fatemi1998 | https://www.tradingview.com/u/Mahdi_Fatemi1998/ | 11 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Mahdi_Fatemi1998
//@version=5
indicator(title='Learn PineScript Inputs', overlay=true)
//some parameters of the indicator() function, when used, will populate the script’s “Inputs” tab with a field. The parameters are timeframe and timeframe_gaps (comment above indicator call and uncomment below to see the effect in inputs window)
//indicator(title='Learn Input', overlay=true, timeframe = "D", timeframe_gaps = false)
// arguments passed to input function
var title = 'title' // this string is shown next to input field in input window
var tooltip = 'tooltip' // this string is shown when hovering on the question mark next to input field
var inline = 'inline' // inputs having the same inline string are placed in the same line (if set to '' the inputs will be in different lines)
var group = 'group' // a header (header inner text is the string) will be added above the inputs having the same group string in all capital letters (if set to '' there will be no group)
var confirm = false // asks the user for input right after adding indicator to chart (price and time are asked differently, user selects them by specifying a point on chart)
// when confirm is true, defval will not have effect (still required) because the user sets the values himself at the beginning, however defval will be used when user set inputs to default at the bottom of the input window
// input.-type-(): receives inputs of the specified -type- (12 possible types)
var boolInput = input.bool (defval=true, title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var colorInput = input.color (defval=color.red, title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var floatInput = input.float (defval=3.14, title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var float2Input = input.float (defval=4.76, title=title, minval=1, maxval=10, step=0.1, tooltip=tooltip, inline=inline, group=group, confirm=confirm) // defval should be between minval and maxval
var float3Input = input.float (defval=1.2, title=title, options=[1.2, 2.3, 3.4, 4.5, 5.6], tooltip=tooltip, inline=inline, group=group, confirm=confirm) // defval should be in options
var intInput = input.int (defval=21, title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var int2Input = input.int (defval=30, title=title, minval=5, maxval=40, step=5, tooltip=tooltip, inline=inline, group=group, confirm=confirm) // defval should be between minval and maxval
var int3Input = input.int (defval=9, title=title, options=[9, 18, 27, 36], tooltip=tooltip, inline=inline, group=group, confirm=confirm) // defval should be in options
var priceInput = input.price (defval=20222.58, title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm) // confirm acts different: asks user to choose price from chart while the tooltip is shown in blue box
var sessionInput = input.session (defval='1730-2100', title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var session2Input = input.session (defval='0100-0200', title=title, options=['0100-0200', '1100-1900', '0500-0400'], tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var sourceInput = input.source (defval=close, title=title, tooltip=tooltip, inline=inline, group=group) // no confirm argument
var stringInput = input.string (defval='defval', title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var string2Input = input.string (defval='a', title=title, options=['a', 'b', 'c'], tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var symbolInput = input.symbol (defval='BTCUSDT', title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm) // if the exchange prefix is not provided, the first choice in the list will be selected
var text_areaInput = input.text_area(defval="text\ntext\ntext", title=title, tooltip=tooltip, group=group, confirm=confirm) // no inline argument, next inputs move upward to be inline with others, tooltip question mark is shown next to title
var timeInput = input.time (defval=timestamp('Feb 01 2020 22:10:05'), title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm) // confirm acts different: asks user to choose time from chart while the tooltip is shown is blue box
var timeframeInput = input.timeframe(defval='D', title=title, tooltip=tooltip, inline=inline, group=group, confirm=confirm)
var timeframe2Input = input.timeframe(defval='3S', title=title, options=['3S', '3', '3D','3W', '3M'], tooltip=tooltip, inline=inline, group=group, confirm=confirm)
// either (options) or (minval, maxval, step) can be in one input parameters not both and defval should meet the limits they constraint
// if the script contains only one source input, then the user can also select an output from another indicator on their chart as the source
// if several inputs have the same inline string, one tooltip will be shown at the end of all inputs and the tooltip text will be the tooltip input of the last input having the same inline
var price2Input = input.price(defval=20222.58, title=title, tooltip='***THIS-TOOLTIP-WONT-BE-SHOWN***', inline=inline, group='one group for inline inputs', confirm=true)
var time2Input = input.time (defval=timestamp('Feb 01 2020 22:10:05'), title=title, tooltip='this tooltip will be shown' , inline=inline, group='one group for inline inputs', confirm=true)
// however, if text_area input be among inputs having the same inline argument, inputs will break in to 3 parts with three tooltips:
// 1. part before the text area with tooltip text of the last input in the part
// 2. part containing the text area with tooltip text of the text area input
// 3. part after the text area with tooltip text of the last input in the part
// note: the parts in the input window are not placed in the same order as they are in the script so the groups might be different than what expected
// getting multiple price inputs
price1mInput = input.price(defval=19700, title='price1', tooltip='enter price 1', inline='', group='multiple price inputs', confirm=true)
price2mInput = input.price(defval=29800, title='price2', tooltip='enter price 2', inline='', group='multiple price inputs', confirm=true)
price3mInput = input.price(defval=39900, title='price3', tooltip='enter price 3', inline='', group='multiple price inputs', confirm=true)
// getting multiple time inputs
time1mInput = input.time(defval=timestamp('Sep 16 2020 12:58:09'), title='time1', tooltip='enter time 1', inline='', group='multiple time inputs', confirm=true)
time2mInput = input.time(defval=timestamp('Sep 16 2020 12:58:09'), title='time2', tooltip='enter time 2', inline='', group='multiple time inputs', confirm=true)
time3mInput = input.time(defval=timestamp('Sep 16 2020 12:58:09'), title='time3', tooltip='enter time 3', inline='', group='multiple time inputs', confirm=true)
// getting a time and price input on two requests
pricedInput = input.price(defval=39900 , title='price double', tooltip='enter price (double)', inline='', group='multiple price inputs', confirm=true)
timedInput = input.time (defval=timestamp('Sep 16 2020 12:58:09'), title='time double' , tooltip='enter time (double)' , inline='', group='multiple time inputs' , confirm=true)
// the order of receiving price or time inputs: if the first price or time is price, all price inputs will be received (regardless of their further order) and if the first one is time then the time inputs will be received first
// the above double price, time input will be received individually because they do not have the same inline
// getting a time and price input on a single request (same inline and same group, horizintal and vertical position of ONE specified point on chart determines both inputs at once)
price2dInput = input.price(defval=49900 , title='price2 double', tooltip='enter price 2 (double)', inline='single request', group='single request group', confirm=true)
time2dInput = input.time (defval=timestamp('Sep 16 2020 13:26:09'), title='time2 double' , tooltip='enter time 2 (double)' , inline='single request', group='single request group', confirm=true)
// input(): automatically detects the input type using the defval argument (only supports: bool, color, int, float, string and price-related source like close, hl2, hl3, etc.)
auto2Input = input(defval='some text 1', title='title argumant in input func', tooltip='this text is shown when hovering on question mark next to the input')
// Uncomment the code below and it gives error (no defval input)
//auto_input1 = input(title='title_in_input_func', tooltip='this text is shown when hovering on question mark next to the input')
// if title argument is not set the variable name is used instead
variableNameInput = input(defval='some text 2')
// however, if the title is set to empty string ('') for any input the variable name will not be shown for it
// this is helpful in order to let the user more easily identify the thing which to color is related (using inline is recommended at this case)
sourcecInput = input.source(defval=close, title='source for color test', tooltip='select source', inline='color line', group='color title test')
colorcInput = input.color (defval=color.red, title='', tooltip='select color', inline='color line', group='color title test', confirm=false)
// Inputs user manual : https://www.tradingview.com/pine-script-docs/en/v5/concepts/Inputs.html
// Inputs reference manual: https://www.tradingview.com/pine-script-reference/v5/#fun_input{dot}bool
// Inputs user manual keypoints:
// 1. 4 ways to open settings of an indicator
// 2. flow of script's execution when user changes inputs of an indicator that is already on chart
// 3. all input parameters must be of 'const' type meaning they should be known at compile time and can't change during scripts execution
// 4. when using dynamic (or series) color componenets the color widgets will not appear in style settings of indicator (example of dynamic color: bbHiColor = color.new(color.gray, high > bbHi ? 60 : 0)) and
// this is one use case for color input (we usually set color in style settings of indicator and in those cases there is no need to receive the color by input*() functions)
// 5. if symbol input has defval='' and user don't give it a value, code will call request.security() where the symbol input variable name is used to fill its value (gets current symbool and use it as symbol input)
// 6. place the inputs in code in the order suggested by pinescript user manual style guide
// 7. to vertically align the inputs add spaces inside the '' not between '' and , in order to not just vertically align the code but also vertically align inputs in inputs window so user will have better experience
// these space should be Unicode EN spaces (U+2002). Unicode spaces are necessary because ordinary spaces would be stripped from the label
// 8. we use the group parameter to distinguish between the two sections of inputs. we use a constant to hold the name of the groups. this way, if we decide to change the name of the group,
// we only need to change it in one place
plot(na) |
Adjusted OBV | https://www.tradingview.com/script/3VHYsAyD-Adjusted-OBV/ | a_lost_hero | https://www.tradingview.com/u/a_lost_hero/ | 8 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © a_lost_hero
//@version=5
indicator("Adjusted OBV")
totalwidth = nz((high - low),0)
topwickwidth = if close >= open
high - close
else
high - open
bottomwickwidth = if close >= open
open - low
else
close - low
candlewidth = if close >= open
close - open
else
open - close
topwickpercent = topwickwidth / totalwidth
bottomwickpercent = bottomwickwidth / totalwidth
candlepercent = candlewidth / totalwidth
wickvolume = volume * (topwickpercent + bottomwickpercent)
candlevolume = volume * candlepercent
volatility = (topwickwidth + bottomwickwidth) / totalwidth
if close >= open
candlevolume := 0 + candlevolume
else
candlevolume := 0 - candlevolume
var float aobv = nz(candlevolume, 0)
aobv := aobv + nz(candlevolume,0)
plot(aobv, color=color.rgb(255, 136, 0))
plot(ta.obv, color=color.rgb(0, 13, 255))
|
Tick Profile Heatmap | https://www.tradingview.com/script/UsTY4NAD-Tick-Profile-Heatmap/ | syntaxgeek | https://www.tradingview.com/u/syntaxgeek/ | 46 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// Copyright syntaxgeek, coleJustice, LuxAlgo (https://www.tradingview.com/script/5MggSfGG-Volume-Profile-LUX/)
// A use of the volume profile based on code by coleJustice which originally utilized LuxAlgo, I wanted to have a profile of where price aligned with TICK extreme prints
// This makes zero use of volume as the original code had done, so please do not confuse this with volume profile.
// I also adjusted row size to the max to present the highest resolution as was possible as I felt it necessary for the intended usecase.
// A variation of a Volume Profile based on code originally by LuxAlgo. The traditional bar chart is replaced with full-width bars that are brighter for high volume price levels.
// Like a traditional VP, the purpose is to visualise how volume corresponds to specific price levels, allowing you to get a quick idea of where the most activity is occurring,
// and where it hasn't been. This information may provide clues as to where price action may return, areas of support and resistance, and regions where price may move quickly.
// Inputs are set up such that you can customize the lookback period, number of rows, and width of rows for most major timeframes individually.
// Timeframes between those available will use the next lower timeframe settings (e.g., 2m chart will use the 1m settings.)
// This indicator is experimental and is likely to receive further updates.
//@version=5
indicator('Tick Profile Heatmap', 'Tick Profile Heatmap', true, max_bars_back=1000, max_boxes_count=500)
import PineCoders/VisibleChart/3 as PCvc
tickSymbol = input.symbol("USI:TICK", "TICK Variant", "NYSE Tick is default but there are others for NASDAQ, AMEX, etc.", group="TICK")
tickSource = input.source(hlc3, "TICK Source", "High and low are always utilized for threshold evaluation, but the source utilized for cumulative is up to user.")
tickUpperThreshold = input.int(500, "TICK Upper Threshold", group="TICK Thresholds", inline="Thresholds")
tickLowerThreshold = input.int(-500, "TICK Lower Threshold", group="TICK Thresholds", inline="Thresholds")
useVisibleRange = input.bool(true, "Use Visible Range", inline="vr", group=' Lookback # Rows')
numRows_vr = input.int(500, title='', minval=1, maxval=500, inline="vr", group=' Lookback # Rows')
lookbackLength_1m = input.int(780, ' 1m', minval=1, maxval=1000, group=' Lookback # Rows', inline="1m")
numRows_1m = input.int(250, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="1m",
tooltip = "Lookback period (in bars) and number of rows for each timeframe. Timeframes between those defined here use the next closest lower timeframe.")
lookbackLength_5m = input.int(390, ' 5m', minval=1, maxval=1000, group=' Lookback # Rows', inline="5m")
numRows_5m = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="5m")
lookbackLength_15m = input.int(260, '15m', minval=1, maxval=1000, group=' Lookback # Rows', inline="15m")
numRows_15m = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="15m")
lookbackLength_30m = input.int(260, '30m', minval=1, maxval=1000, group=' Lookback # Rows', inline="30m")
numRows_30m = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="30m")
lookbackLength_1h = input.int(188, ' 1h', minval=1, maxval=1000, group=' Lookback # Rows', inline="1h")
numRows_1h = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="1h")
lookbackLength_1d = input.int(120, ' D', minval=1, maxval=1000, group=' Lookback # Rows', inline="1d")
numRows_1d = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="1d")
lookbackLength_1w = input.int(75, ' W', minval=1, maxval=1000, group=' Lookback # Rows', inline="1w")
numRows_1w = input.int(500, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="1w")
lookbackLength_fallback = input.int(100, '___', minval=1, maxval=1000, group=' Lookback # Rows', inline="fallback")
numRows_fallback = input.int(250, title='', minval=1, maxval=500, group=' Lookback # Rows', inline="fallback",
tooltip='These values are used for any periods not captured between the above.')
PoCThickness = input.int(4, title="Point of Control ", tooltip = "Thickness and color of the Point of Control Plot", group="Style", inline="poc")
PoCColor = input.color(color.orange, title="", group="Style", inline="poc")
lowVolColor = input.color(color.new(color.lime, 30), title="Volume Gradient ", inline="grad", group="Style", tooltip = "Colors for the volume rows from Highest to Lowest.")
highVolColor = input.color(color.new(color.white, 99), title="", inline="grad", group="Style")
gradientMult = input.float(1.5, minval=0.1, step=0.1, title="Gradient Multiplier", group="Style", tooltip="Adjusts sharpness of the gradient by emphasizing bright areas and deemphasizing dim areas.")
//-----------------------------------------------------------------------------------------
isNewPeriod = ta.change(time('D'))
var float _chartTfInMinutes = timeframe.multiplier * (timeframe.isseconds ? 1. / 60 : timeframe.isminutes ? 1. : timeframe.isdaily ? 60. * 24 : timeframe.isweekly ? 60. * 24 * 7 : timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
lookbackLength = _chartTfInMinutes < 5 ? lookbackLength_1m :
_chartTfInMinutes < 15 ? lookbackLength_5m :
_chartTfInMinutes < 30 ? lookbackLength_15m :
_chartTfInMinutes < 60 ? lookbackLength_30m :
_chartTfInMinutes < 120 ? lookbackLength_1h :
_chartTfInMinutes < 10080 ? lookbackLength_1d :
_chartTfInMinutes == 10080 ? lookbackLength_1w : lookbackLength_fallback
numRows = useVisibleRange ? numRows_vr :
_chartTfInMinutes < 5 ? numRows_1m :
_chartTfInMinutes < 15 ? numRows_5m :
_chartTfInMinutes < 30 ? numRows_15m :
_chartTfInMinutes < 60 ? numRows_30m :
_chartTfInMinutes < 120 ? numRows_1h :
_chartTfInMinutes < 10080 ? numRows_1d :
_chartTfInMinutes == 10080 ? numRows_1w : numRows_fallback
//Below is a modified version of the code written by LuxAlgo for https://www.tradingview.com/script/5MggSfGG-Volume-Profile-LUX/
var rowsBoxes = array.new_box()
if barstate.isfirst
for i = 0 to numRows - 1 by 1
array.push(rowsBoxes, box.new(na, na, na, na))
var pocLine = line.new(na, na, na, na, width=2)
if (useVisibleRange)
lookbackLength := PCvc.bars() + 1
lookbackLength_fallback := PCvc.bars() + 1
leftBarIndex = PCvc.leftBarIndex()
rightBarIndex = PCvc.rightBarIndex()
rightBarZeroIndex = bar_index - rightBarIndex
highest = useVisibleRange ? PCvc.high() : ta.highest(lookbackLength)
lowest = useVisibleRange ? PCvc.low() : ta.lowest(lookbackLength)
priceRange = (highest-lowest)/numRows
line poc = na
box rowBox = na
levels = array.new_float(0)
sumVol = array.new_float(0)
// Table Dashboard (8 columns) For Debugging during dev
//tablePosition = position.top_center
//var table moodTable = table.new(tablePosition, 3, 1, border_width = 3)
//f_fillCell(_column, _row, _cellText, _c_color) =>
//table.cell(moodTable, _column, _row, _cellText, bgcolor = color.new(_c_color, 75), text_color = _c_color)
[v_marketTickHigh, v_marketTickLow, v_marketTickSetSource] = request.security(tickSymbol, timeframe.period, [high, low, tickSource])
if barstate.islastconfirmedhistory
//f_fillCell(0, 0, "leftMost: " + str.tostring(leftBarIndex), color.white)
//f_fillCell(1, 0, "rightMost: " + str.tostring(rightBarIndex), color.white)
//f_fillCell(2, 0, "bars: " + str.tostring(rightBarZeroIndex), color.white)
for i = 0 to numRows by 1
array.push(levels, lowest + i / numRows * (highest - lowest))
for j = 0 to numRows - 1 by 1
sum = 0.
for k = rightBarZeroIndex to lookbackLength + rightBarZeroIndex - 1 by 1
if v_marketTickHigh > tickUpperThreshold or v_marketTickLow < tickLowerThreshold
sum := high[k] > array.get(levels, j) and low[k] < array.get(levels, j + 1) ? sum + v_marketTickSetSource[k] : sum
array.push(sumVol, sum)
for j = 0 to numRows - 1 by 1
mult = math.pow(array.get(sumVol, j) / array.max(sumVol), gradientMult)
rowBox := array.get(rowsBoxes, j)
volumeLevel = array.get(levels, j)
box.set_lefttop(rowBox, bar_index - lookbackLength - rightBarZeroIndex, volumeLevel-(priceRange/2))
box.set_rightbottom(rowBox, bar_index - rightBarZeroIndex, volumeLevel + (priceRange/2))
box.set_bgcolor(rowBox, color.from_gradient(mult * 99, 0, 100, highVolColor, lowVolColor))
box.set_border_width(rowBox, 0)
if mult == 1
avg = math.avg(volumeLevel, array.get(levels, j + 1))
line.set_xy1(pocLine, bar_index - lookbackLength - rightBarZeroIndex + 1, avg)
line.set_xy2(pocLine, bar_index, avg)
line.set_color(pocLine, PoCColor)
line.set_style(pocLine, line.style_dotted)
line.set_width(pocLine, PoCThickness)
|
PM RTH AH VWAPs [vnhilton] | https://www.tradingview.com/script/oJycKjll-PM-RTH-AH-VWAPs-vnhilton/ | vnhilton | https://www.tradingview.com/u/vnhilton/ | 8 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © vnhilton
//@version=5
indicator("PM RTH AH VWAPs [vnhilton]", "PM RTH AH VWAPs", true)
//Parameters
src = input(hlc3, "Source For VWAP")
//PM VWAP
vwap = ta.vwap(src, timeframe.change("D"))
pmVWAP = request.security(ticker.modify(syminfo.tickerid, session.extended), timeframe.period, vwap)
//RTH VWAP
vwapRTH = ta.vwap(src, session.isfirstbar_regular)
//AH VWAP
var float vwapSum = na
var float volumeSum = na
var bool sessionStarted = false
if time(timeframe.period, "1600-2000", syminfo.timezone)
if not sessionStarted
vwapSum := src * volume
volumeSum := volume
sessionStarted := true
else
vwapSum := vwapSum[1] + src * volume
volumeSum := volumeSum[1] + volume
else
sessionStarted := false
vwapAH = volumeSum != 0 ? vwapSum / volumeSum : na
//Plots
pmPlot = plot(session.ispremarket ? pmVWAP : na, "PM VWAP", color.new(#002652, 0), style=plot.style_linebr)
rthPlot = plot(session.ismarket ? vwapRTH : na, "RTH VWAP", color.new(#002652, 0), style=plot.style_linebr)
ahPlot = plot(session.ispostmarket ? vwapAH : na, "AH VWAP", color.new(#002652, 0), style=plot.style_linebr) |
ATR Candles | https://www.tradingview.com/script/X6m8ySec-ATR-Candles/ | Amphibiantrading | https://www.tradingview.com/u/Amphibiantrading/ | 198 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Amphibiantrading
//@version=5
indicator("ATR/ADR Candles", overlay = true)
//inputs
var g1 = 'ATR/ADR Settings'
adrOrAtr = input.string('ATR', 'ATR or ADR', options = ['ATR', 'ADR'])
atrLenLong = input.int(20, 'ATR/ADR Long Lookback', group = g1)
atrLenShort = input.int(5, 'ATR/ADR Short Lookback' ,group = g1)
bgColorBool = input.bool(true, ' ', inline = '1', group = g1)
bgColor = input.color(color.new(color.yellow,90), 'Show ATR/ADR Expansion', inline = '1', group = g1,
tooltip = 'Color Background when Short ATR/ADR > Long ATR/ADR')
var g2 = 'Candle Colors'
atrLenMed = input.int(10, 'ATR/ADR Length for Candles', inline = '0', group = g2,
tooltip = 'ATR length used to calculate candle colors')
atrSrc = input.string('Open', 'Calculate Days ATR Move From', options = ['Open', 'Previous Close', 'Daily Range'],
group = g2, tooltip = 'Calculate the ATR move from the open, previous close, or full daily range. ADR will always use daily range.')
fullAtrBool = input.bool(true, ' ', inline = '1', group = g2)
contraBool = input.bool(true, ' ', inline = '2', group = g2)
expan1Bool = input.bool(true, ' ', inline = '3', group = g2)
expan2Bool = input.bool(true, ' ', inline = '4', group = g2)
contractMult = input.float(0.5, 'Contraction Threshold', minval = .1, maxval = .99, step = .01, inline = '2',
group = g2, tooltip = 'A candle thats range is less than chosen % of ATR/ADR')
multi2 = input.float(1.5, 'Expansion Threshold', minval = 1.25, maxval = 10, step = .25, inline = '3', group = g2,
tooltip = 'A candle thats range is greater than chosen % of ATR/ADR')
multi3 = input.float(2.0, 'Expansion Threshold', minval = 1.5, maxval = 10, step = .25, inline = '4', group = g2,
tooltip = 'A candle thats range is greater than chosen % of ATR/ADR')
color1 = input.color(color.rgb(255, 213, 151), 'Full ATR/ADR', inline = '1', group = g2)
color2 = input.color(color.rgb(179, 246, 255), ' ', inline = '2', group = g2)
color3 = input.color(color.rgb(34, 130, 255), ' ', inline = '3', group = g2)
color4 = input.color(color.rgb(255, 0, 119), ' ', inline = '4', group = g2)
var g3 = 'Ranges'
showLines = input.bool(false, 'Show Expansion Candle Open/Close', inline = '1', group = g3)
onlyLast = input.bool(false, 'Only Show Last Lines', inline = '1', group = g3)
maxLineLen = input.int(9, 'Delete Lines After Days', inline = '2', group = g3)
lineStyle = input.string('Solid', 'Line Style', options = ['Solid', 'Dashed', 'Dotted'], inline = '3', group = g3)
lineColor = input.color(color.red, ' ', inline = '3', group = g3)
var g4 = 'ATR Labels'
showAtrLabels = input.bool(true, ' ', inline = '1', group = g4)
yPos = input.string("Bottom", "ATR/ADR Labels", options = ["Top", "Middle", "Bottom"], inline = '1', group = g4)
xPos = input.string("Right", " ", options = ["Right","Center", "Left"], inline = '1', group = g4)
labelColor = input.color(color.new(color.white,100), 'Label Color', inline = '2', group = g4)
textColor = input.color(color.black, 'Text Color', inline = '2', group = g4)
//methods
method switcher(string this)=>
switch this
'Solid' => line.style_solid
'Dashed' => line.style_dashed
'Dotted' => line.style_dotted
//table and array for boxes
var table atrTable = table.new(str.lower(yPos) + '_' + str.lower(xPos), 1, 4,
border_color = color.new(color.white,100), border_width = 2)
var line openLine = na, var line closeLine = na
var line [] openLinesArr = array.new_line()
var line [] closeLinesArr = array.new_line()
//atrs & adrs
dailyRange = high - low
atrLong = ta.atr(atrLenLong)
atrShort = ta.atr(atrLenShort)
atrMed = ta.atr(atrLenMed)
adrLong = ta.sma(dailyRange,atrLenLong)
adrShort = ta.sma(dailyRange,atrLenShort)
adrMed = ta.sma(dailyRange,atrLenMed)
//calcs
contract1 = adrOrAtr == 'ADR' ? dailyRange <= adrMed * contractMult : adrOrAtr == 'ATR' ? close < open and atrSrc == 'Open' ? (open - close) <= atrMed * contractMult : close > open and atrSrc == 'Open' ? (close - open) <= atrMed * contractMult :
close < close[1] and atrSrc == 'Previous Close' ? (close[1] - close) <= atrMed * contractMult : close > close[1] and atrSrc == 'Previous Close' ? (close - close[1]) <= atrMed * contractMult :
atrSrc == 'Daily Range' ? dailyRange <= atrMed * contractMult : na : na
expan1 = adrOrAtr == 'ADR' ? dailyRange >= adrMed * multi2 : adrOrAtr == 'ATR' ? close < open and atrSrc == 'Open' ? (open - close) >= atrMed * multi2 : close > open and atrSrc == 'Open' ? (close - open) >= atrMed * multi2 :
close < close[1] and atrSrc == 'Previous Close' ? (close[1] - close) >= atrMed * multi2 : close > close[1] and atrSrc == 'Previous Close' ? (close - close[1]) >= atrMed * multi2 :
atrSrc == 'Daily Range' ? dailyRange >= atrMed * multi2 : na : na
expan2 = adrOrAtr == 'ADR' ? dailyRange >= adrMed * multi3 : adrOrAtr == 'ATR' ? close < open and atrSrc == 'Open' ? (open - close) >= atrMed * multi3 : close > open and atrSrc == 'Open' ? (close - open) >= atrMed * multi3 :
close < close[1] and atrSrc == 'Previous Close' ? (close[1] - close) >= atrMed * multi3 : close > close[1] and atrSrc == 'Previous Close' ? (close - close[1]) >= atrMed * multi3 :
atrSrc == 'Daily Range' ? (high - low) >= atrMed * multi3 : na : na
isFull = adrOrAtr == 'ADR' ? dailyRange >= adrMed : adrOrAtr == 'ATR' ? close < open and atrSrc == 'Open' ? (open - close) >= atrMed : close > open and atrSrc == 'Open' ? (close - open) >= atrMed :
close < close[1] and atrSrc == 'Previous Close' ? (close[1] - close) >= atrMed : close > close[1] and atrSrc == 'Previous Close' ? (close - close[1]) >= atrMed :
atrSrc == 'Daily Range' ? dailyRange >= atrMed : na : na
expansion = adrOrAtr == 'ATR' ? atrShort > atrLong : adrShort > adrLong
isExpan = expan1 or expan2
//plots
barcolor(expan2 and expan2Bool ? color4 : expan1 and expan1Bool ? color3 : isFull and fullAtrBool ? color1 :
contract1 and contraBool ? color2 : na)
bgcolor(expansion and bgColorBool ? bgColor : na)
if barstate.islast and showAtrLabels
table.cell(atrTable, 0, 0, ' ', bgcolor = color.new(color.white, 100))
table.cell(atrTable, 0, 1, adrOrAtr == 'ATR' ? 'ATR Long: $' + str.tostring(atrLong, format.mintick) : 'ADR Long: $' + str.tostring(adrLong, format.mintick), text_color = textColor,
text_halign = text.align_left, bgcolor = labelColor)
table.cell(atrTable, 0, 2, adrOrAtr == 'ATR' ? 'ATR Short: $' + str.tostring(atrShort, format.mintick) : 'ADR Short: $' + str.tostring(adrShort, format.mintick), text_color = textColor,
text_halign = text.align_left, bgcolor = labelColor)
table.cell(atrTable, 0, 3, ' ', bgcolor = color.new(color.white, 100))
if isExpan and showLines
openLine := line.new(bar_index, open, bar_index + 1, open, extend = extend.right, style = lineStyle.switcher(), color = lineColor)
closeLine := line.new(bar_index, close, bar_index + 1, close, extend = extend.right, style = lineStyle.switcher(), color = lineColor)
openLinesArr.unshift(openLine), closeLinesArr.unshift(closeLine)
if onlyLast
(openLine[1]).delete(), (closeLine[1]).delete()
for [ind, l] in openLinesArr
if bar_index - l.get_x1() > maxLineLen
line.delete(openLinesArr.get(ind))
for [ind, l] in closeLinesArr
if bar_index - l.get_x1() > maxLineLen
line.delete(closeLinesArr.get(ind))
//alerts
if expansion and not expansion[1]
alert('ATR/ADR Expansion', alert.freq_once_per_bar_close)
|
SPX ES Spread | https://www.tradingview.com/script/6wR9Dmnm-SPX-ES-Spread/ | mrmccraig | https://www.tradingview.com/u/mrmccraig/ | 38 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © mrmccraig
//@version=5
indicator("SPX ES Spread", overlay=true)
ESticker = input.string("ES1!", "ES Symbol")
SPXticker = input.string("SPX", "SPX Symbol")
theSource = input.source(close, "Source")
calcMethod = input.string("Source", "Calculation Method", options=["Source", "MA"], tooltip="If 'source' is selected, the difference in the two indices is simply the difference of the two. If 'MA' is selected, a moving average is used.")
maType = input.string("SMA", "MA Type", options=["SMA", "EMA"])
maLen = input.int(21, "MA Length", minval=1)
precision = input.int(1, "Precision", tooltip="How many decimal places the spread will be rounded to.")
tableBGColor = input.color(color.gray, "Table Background")
tableText = input.color(color.white, "Table text, frame")
tablePosition = input.string("Top Right", "Table Position", options=["Top Right", "Top Center", "Top Left"])
// check if we're on either ES chart or SPX chart
symbolCheck = syminfo.ticker == SPXticker ? "SPX" : syminfo.ticker == ESticker ? "ES" : na
otherSymbolValue = 0.00
spreadValue = 0.00
otherSymbolValue := request.security(symbolCheck == "SPX" ? ESticker : SPXticker, timeframe.period, theSource)
if symbolCheck == "SPX" or symbolCheck == "ES"
spreadValue := calcMethod == "Source" ? otherSymbolValue - theSource : maType == "SMA" ? ta.sma(otherSymbolValue - theSource, maLen) : ta.ema(otherSymbolValue - theSource, maLen)
spreadValue := math.round(spreadValue, precision)
showTable = not na(symbolCheck)
tablePos = switch (tablePosition)
"Top Right" => position.top_right
"Top Center" => position.top_center
"Top Right" => position.top_left
spreadTable = showTable ? table.new(tablePos, 2, 2, bgcolor=tableBGColor, frame_color=tableText, frame_width=1, border_color=tableText, border_width=1) : na
if barstate.islast and not na(symbolCheck)
table.cell(spreadTable, 0, 0, text=symbolCheck == "SPX" ? ESticker : symbolCheck == "ES" ? SPXticker : "", text_color=tableText)
table.cell(spreadTable, 1, 0, text=str.tostring(otherSymbolValue), text_color=tableText)
table.cell(spreadTable, 0, 1, text="Spread", text_color=tableText)
table.cell(spreadTable, 1, 1, text=str.tostring(spreadValue), text_color=tableText)
|
Price Action Color Forecast (Expo) | https://www.tradingview.com/script/rrT9dacO-Price-Action-Color-Forecast-Expo/ | Zeiierman | https://www.tradingview.com/u/Zeiierman/ | 1,355 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Zeiierman
//@version=5
indicator("Price Action Color Forecast (Expo)",overlay=true,max_boxes_count=5000,max_lines_count=500)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Tooltips {
string t1 = "The candle lookback length refers to the number of bars, starting from the current one, that will be examined in order to find a similar event in the past."
string t2 = "The amount of Forecast candles that should be displayed in the future."
string t3 = "Background color divider between price and forecast."
string t4 = "Displays the current events found"
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Inputs {
Series = input.int(7,"Candle Series",1,20,tooltip=t1)
Forecast = input.int(100,"Forecast Candles",1,166,tooltip=t2)
Divider = input.bool(true,"Forecast Divider",t3)
Display = input.bool(true,"Display Event",t4)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Types {
type Event
box currentEvent
box pastEvent
box prediction
array<box> candle
array<line> wick
type Data
array<int> b
array<int> d
array<float> o
array<float> h
array<float> l
array<float> c
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Variables & Arrays {
b = bar_index
var data = Data.new(array.new<int>(),
array.new<int>(),
array.new<float>(),
array.new<float>(),
array.new<float>(),
array.new<float>())
var event = Event.new(box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dotted,
bgcolor=color.new(color.teal,75)),
array.new<box>(Forecast),
array.new<line>(Forecast))
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Methods {
//Store Data
method Store(Data x)=>
int B = b
int bin = close>open?1:close<open?-1:0
float O = open
float H = high
float L = low
float C = close
x.b.unshift(B)
x.d.unshift(bin)
x.o.unshift(O)
x.h.unshift(H)
x.l.unshift(L)
x.c.unshift(C)
//Candle Plots
method Candle(Event e,x,i)=>
int dist = 1
float prev = x.c.get(i)
float diff = ((close-prev)/prev)+1
for j=i-1 to i-Forecast
idx = j-i+Forecast
if j<0
break
else
pos = x.d.get(j)
top = (pos>0?x.c.get(j):x.o.get(j))*diff
bot = (pos>0?x.o.get(j):x.c.get(j))*diff
hi = (x.h.get(j))*diff
lo = (x.l.get(j))*diff
col = pos==1?#26a69a:pos==-1?#ef5350:chart.fg_color
candle = e.candle.get(idx)
if na(candle)
e.candle.set(idx,box.new(b+dist,top,b+dist+2,bot,na,bgcolor=col))
e.wick.set(idx,line.new(b+dist+1,hi,b+dist+1,lo,color=col))
else
box.set_lefttop(e.candle.get(idx),b+dist,top)
box.set_rightbottom(e.candle.get(idx),b+dist+2,bot)
box.set_bgcolor(e.candle.get(idx),col)
line.set_xy1(e.wick.get(idx),b+dist+1,hi)
line.set_xy2(e.wick.get(idx),b+dist+1,lo)
line.set_color(e.wick.get(idx),col)
dist += 3
//Events Display
method Events(Event e,idx,h1,l1,h2,l2,fh,fl)=>
int start = idx.get(Series-1)
int end = idx.get(0)
e.currentEvent.set_lefttop(b-Series+1,h1.max())
e.currentEvent.set_rightbottom(b,l1.min())
e.pastEvent.set_lefttop(start,h2.max())
e.pastEvent.set_rightbottom(end,l2.min())
e.prediction.set_lefttop(end+1,fh.max())
e.prediction.set_rightbottom(math.min(b,end+Forecast),fl.min())
//Current Event
method Series(Data x)=>
data.Store()
bool found = false
if barstate.islast
events = x.d.slice(0,Series)
for i=Series to x.d.size()-Series
elements = x.d.slice(i,i+Series)
equal = 0
for [k,this] in elements
if this==events.get(k)
equal += 1
if equal==Series
found := true
event.Candle(data,i)
if Display
bar = x.b.slice(i,i+Series)
h1 = x.h.slice(0,Series)
l1 = x.l.slice(0,Series)
h2 = x.h.slice(i,i+Series)
l2 = x.l.slice(i,i+Series)
fh = i-Forecast<0?x.h.slice(0,i-1):x.h.slice(i-Forecast,i-1)
fl = i-Forecast<0?x.l.slice(0,i-1):x.l.slice(i-Forecast,i-1)
event.Events(bar,h1,l1,h2,l2,fh,fl)
break
if barstate.islast and not found
runtime.error("Couldn't find similar candle series event. \nFix: Decrease Candle Series length")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Divider {
bgcolor(Divider and barstate.islast?color.new(chart.fg_color,80):na,1)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Run Code {
data.Series()
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~} |
PineTradingbotWebhook | https://www.tradingview.com/script/xOO4qW1P-PineTradingbotWebhook/ | AlphaCentauri66367 | https://www.tradingview.com/u/AlphaCentauri66367/ | 7 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © AlphaCentauri66367
//
// Credits:
// JSON functions taken from © beskrovnykh: https://www.tradingview.com/script/HFGmR9ST-market-monitor/
//@version=5
// @description Provides Webhook JSON strings for Tbot on Tradingboat
library("PineTradingbotWebhook")
_metricToJson(name, value) =>
str.format("'{'\"name\": \"{0}\", \"value\": {1}'}'", str.tostring(name), str.tostring(value))
// @function Creates a Webhook message for Tbot on Tradingboat
// @param webhookKey the unique key to the Flask (TVWB) server - // Use format like WebhookReceived:123456
// @param orderRef this will be used to create the order reference ID, together with timeframe and clientID
// @param direction the same as the strategy's direction - strategy.entrylong, strategy.entryshort, strategy.exitlong, strategy.exitshort, strategy.close, strategy.close_all
// @param qty default value is -1e10 indicating all contracts/units
// @param entryLimit this is same to strategy.entry()'s limit parameter
// @param entryStop this is same to strategy.entry()'s stop parameter
// @param exitLimit this is the same to strategy.exit()'s limit parameter
// @param exitStop this is the same to strategy.exit()'s stop parameter
// @param contract this will be translated to secType in ib insync. stock, forex, crypto
// @param clientId this is for IB Gateway/TWS's clientID which should start with 1
// @returns JSON as a series string
export makeWebhookJson(
simple string webhookKey,
simple string orderRef = 'defOrderId',
simple string direction,
float qty = -1e10,
float entryLimit = 0.0,
float entryStop = 0.0,
float exitLimit = 0.0,
float exitStop = 0.0,
simple string contract = 'stock',
int clientId = 1
) =>
metrics = array.new_string()
array.push(metrics, _metricToJson("entry.limit", math.round_to_mintick(entryLimit)))
array.push(metrics, _metricToJson("entry.stop", math.round_to_mintick(entryStop)))
array.push(metrics, _metricToJson("exit.limit", math.round_to_mintick(exitLimit)))
array.push(metrics, _metricToJson("exit.stop", math.round_to_mintick(exitStop)))
array.push(metrics, _metricToJson("qty", math.round_to_mintick(qty)))
array.push(metrics, _metricToJson("price", close))
metricsJson = str.format("[{0}]", array.join(metrics,', '))
messageContent = array.new_string()
array.push(messageContent, str.format("\"timestamp\": {0,number,#}", timenow))
array.push(messageContent, str.format("\"ticker\": \"{0}\"",syminfo.ticker))
array.push(messageContent, str.format("\"currency\": \"{0}\"",syminfo.currency))
array.push(messageContent, str.format("\"timeframe\": \"{0}\"",timeframe.period))
array.push(messageContent, str.format("\"clientId\": {0}",clientId))
array.push(messageContent, str.format("\"key\": \"{0}\"",webhookKey))
array.push(messageContent, str.format("\"contract\": \"{0}\"",contract))
array.push(messageContent, str.format("\"orderRef\": \"{0}\"",orderRef))
array.push(messageContent, str.format("\"direction\": \"{0}\"",direction))
array.push(messageContent, str.format("\"metrics\": {0}",metricsJson))
messageJson = str.format("'{'{0}'}'",array.join(messageContent, ', '))
|
Seasonality [TFO] | https://www.tradingview.com/script/wiXmhDwT-Seasonality-TFO/ | tradeforopp | https://www.tradingview.com/u/tradeforopp/ | 1,415 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © tradeforopp
//@version=5
indicator("Seasonality [TFO]", "Seasonality v1.0 [TFO]", false, max_lines_count = 500, max_boxes_count = 500, max_labels_count = 500)
// -------------------- Inputs --------------------
var g_ANALYSIS = "Analysis"
show_table = input.bool(true, "Statistics Table", tooltip = "Summarized table describing seasonal data for the selected timeframe", group = g_ANALYSIS)
show_analysis = input.bool(true, "Performance Analysis", inline = "ANALYSIS", tooltip = "Histogram showing the average percentage performance for the selected timeframe", group = g_ANALYSIS)
analysis_period = input.string('Daily', "", ['Daily', 'Monthly', 'Quarterly'], inline = "ANALYSIS", group = g_ANALYSIS)
szn_pivots = input.bool(false, "Seasonal Pivots", tooltip = "Shows when the current asset tends to make highs and lows throughout the year, based on an aggregation of daily performance", group = g_ANALYSIS)
pivot_strength = input.int(10, "Pivot Strength", tooltip = "Using a value of 10 for example, a high must be greater than the 10 bars to the left and 10 bars to the right of it in order to be a valid pivot, and vice versa for lows", group = g_ANALYSIS)
var g_EXTRAS = "Extras"
highlight_today = input.bool(true, "Highlight Current Trading Day", tooltip = "Easily find where the current trading day meets up with seasonal averages", group = g_EXTRAS)
show_labels = input.bool(true, "Performance Labels", tooltip = "Labels will be shown in the Performance Analysis to describe the average percent move over the specified period of time", group = g_EXTRAS)
track_change = input.bool(false, "Track Changes", tooltip = "Follows the changes in average performance throughout the year", group = g_EXTRAS)
var g_INDEX = "Indexing"
anchor_boy = input.bool(true, "Anchor to Beginning of Year", tooltip = "All drawings will start anchored to the first trading day of the current year, to easily overlay past performance on the current Daily chart", group = g_INDEX)
use_manual_offset = input.bool(false, "Manual Offset", inline = "OFFSET", tooltip = "Offers a secondary offset so users can overlay these drawings on previous years (with an offset of ~252 * number of years, for example)", group = g_INDEX)
manual_offset = input.int(252, "", inline = "OFFSET", group = g_INDEX)
var g_DIV = "Dividers"
month_div = input.bool(false, "Month", inline = "MDIV", group = g_DIV)
mdiv_style = input.string('Dotted', "", ['Dotted', 'Dashed', 'Solid'], inline = "MDIV", group = g_DIV)
mdiv_color = input.color(color.white, "", inline = "MDIV", group = g_DIV)
qr_div = input.bool(false, "Quarter", inline = "QDIV", group = g_DIV)
qdiv_style = input.string('Dotted', "", ['Dotted', 'Dashed', 'Solid'], inline = "QDIV", group = g_DIV)
qdiv_color = input.color(color.white, "", inline = "QDIV", group = g_DIV)
var g_STYLE = "Style"
main_color = input.color(color.white, "Main Color", group = g_STYLE)
track_color = input.color(color.yellow, "Track Changes", group = g_STYLE)
upper_color = input.color(#08998180, "Performance", inline = "PERFORMANCE", group = g_STYLE)
lower_color = input.color(#f2364580, "", inline = "PERFORMANCE", group = g_STYLE)
high_color = input.color(#08998180, "Seasonal Pivots", inline = "PIVOTS", group = g_STYLE)
low_color = input.color(#f2364580, "", inline = "PIVOTS", group = g_STYLE)
pivot_width = input.int(2, "Seasonal Pivot Width", group = g_STYLE)
divider_width = input.int(1, "Divider Width", group = g_STYLE)
text_size = input.string('Normal', "Text Size", options = ['Auto', 'Tiny', 'Small', 'Normal', 'Large', 'Huge'], group = g_STYLE)
var g_TABLE = "Table"
table_pos = input.string('Top Right', "Position", options = ['Bottom Center', 'Bottom Left', 'Bottom Right', 'Middle Center', 'Middle Left', 'Middle Right', 'Top Center', 'Top Left', 'Top Right'], group = g_TABLE)
table_text = input.color(color.black, "Text Color", group = g_TABLE)
table_frame = input.color(color.black, "Frame Color", group = g_TABLE)
table_border = input.color(color.black, "Border Color", group = g_TABLE)
table_bg = input.color(color.white, "Background Color", group = g_TABLE)
// -------------------- Inputs --------------------
// -------------------- Basic Functions --------------------
get_table_pos(i) =>
result = switch i
"Bottom Center" => position.bottom_center
"Bottom Left" => position.bottom_left
"Bottom Right" => position.bottom_right
"Middle Center" => position.middle_center
"Middle Left" => position.middle_left
"Middle Right" => position.middle_right
"Top Center" => position.top_center
"Top Left" => position.top_left
"Top Right" => position.top_right
result
get_text_size(i) =>
result = switch i
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal
'Large' => size.large
'Huge' => size.huge
'Auto' => size.auto
result
get_line_style(i) =>
result = switch i
'Dotted' => line.style_dotted
'Dashed' => line.style_dashed
'Solid' => line.style_solid
result
get_month(i) =>
result = switch i
1 => 'JAN'
2 => 'FEB'
3 => 'MAR'
4 => 'APR'
5 => 'MAY'
6 => 'JUN'
7 => 'JUL'
8 => 'AUG'
9 => 'SEP'
10 => 'OCT'
11 => 'NOV'
12 => 'DEC'
get_qr(i) =>
result = switch i
1 => 'Q1'
2 => 'Q2'
3 => 'Q3'
4 => 'Q4'
get_period() =>
result = switch analysis_period
'Daily' => 'D'
'Monthly' => 'M'
'Quarterly' => 'Q'
// -------------------- Basic Functions --------------------
// -------------------- Variables & Constants --------------------
[d_open, d_close] = request.security(syminfo.tickerid, "D", [open, close], barmerge.gaps_off, barmerge.lookahead_on)
[m_open, m_close] = request.security(syminfo.tickerid, "M", [open, close], barmerge.gaps_off, barmerge.lookahead_on)
[q_open, q_close] = request.security(syminfo.tickerid, "3M", [open, close], barmerge.gaps_off, barmerge.lookahead_on)
//
var arr_days = array.new_int()
var d_pct = array.new_float()
var d_points = array.new_float()
var d_count = array.new_int()
var d_day = array.new_string()
var d_sorted_pct = array.new_float()
var d_sorted_points = array.new_float()
var d_sorted_count = array.new_int()
var d_sorted_day = array.new_string()
var m_pct_avg = array.new_float()
var q_pct_avg = array.new_float()
//
var int doy = na
var int first_year = na
var int first_xoy = na
var float first_yoy = na
//
if month == 1 and month[1] != 1
first_xoy := bar_index
first_yoy := close[1]
doy := 0
if na(first_year)
first_year := year
if not na(doy)
doy += 1
//
offset = use_manual_offset ? manual_offset : 0
start_idx = anchor_boy ? first_xoy - offset : bar_index
highlight_offset = 20
days_in_year = 252
days_in_month = 21
days_in_qr = 63
period = get_period()
text_size := get_text_size(text_size)
mdiv_style := get_line_style(mdiv_style)
qdiv_style := get_line_style(qdiv_style)
table_pos := get_table_pos(table_pos)
//
szn_idx = switch period
'D' => doy - 1
'M' => month - 1
'Q' => month % 3 - 1
szn_arr = switch period
'D' => d_sorted_pct
'M' => m_pct_avg
'Q' => q_pct_avg
current_pct = switch period
'D' => (d_close - d_open) / d_open
'M' => (m_close - m_open) / m_open
'Q' => (q_close - q_open) / q_open
current_pts = switch period
'D' => (d_close - d_open)
'M' => (m_close - m_open)
'Q' => (q_close - q_open)
num_days = switch period
'D' => days_in_year
'M' => days_in_month
'Q' => days_in_qr
// -------------------- Variables & Constants --------------------
// -------------------- Saving Performance Data --------------------
if not na(doy) and doy <= days_in_year
idx = arr_days.indexof(doy)
pct = (d_close - d_open) / d_open
points = (d_close - d_open)
if idx == -1
arr_days.push(doy)
d_pct.push(pct)
d_points.push(points)
d_count.push(1)
d_day.push(str.tostring(month) + "/" + str.tostring(dayofmonth))
else
d_pct.set(idx, d_pct.get(idx) + pct)
d_points.set(idx, d_points.get(idx) + points)
d_count.set(idx, d_count.get(idx) + 1)
// -------------------- Saving Performance Data --------------------
// -------------------- Plotting Functions --------------------
dividers(base) =>
if month_div
for i = 0 to m_pct_avg.size()
left = start_idx + i * days_in_month
line.new(left, base, left, base, color = mdiv_color, style = mdiv_style, extend = extend.both, width = divider_width)
if qr_div
for i = 0 to q_pct_avg.size()
left = start_idx + i * days_in_qr
line.new(left, base, left, base, color = qdiv_color, style = qdiv_style, extend = extend.both, width = divider_width)
plot_analysis(period, szn_arr, szn_idx, num_days, base) =>
for i = 0 to szn_arr.size() - 1
not_daily = period != 'D'
left = start_idx + i * (not_daily ? num_days : 1)
right = left + (not_daily ? num_days - 1 : 1)
label_x = math.floor(math.avg(left, right))
box_text = switch period
'D' => na
'M' => get_month(i + 1)
'Q' => get_qr(i + 1)
perf = szn_arr.get(i)
col = perf > 0 ? upper_color : lower_color
if not_daily
box.new(left, base + perf, right, base, bgcolor = col, border_color = col, text = box_text, text_color = col)
else
line.new(left, base + perf, left, base, color = col, width = 5)
if show_labels
label.new(label_x, base + perf, str.tostring(perf * 100, format.percent), style = perf > 0 ? label.style_label_down : label.style_label_up, textcolor = main_color, size = text_size, color = #ffffff00)
if track_change and i != szn_arr.size() - 1
next_perf = szn_arr.get(i + 1)
line.new(label_x, base + perf, label_x + (not_daily ? num_days : 1), base + next_perf, color = track_color, width = 2)
if highlight_today and i == szn_idx
line.new(left, base + perf, start_idx + days_in_year - 1, base + perf, style = line.style_dotted, color = main_color, width = 2)
label.new(start_idx + days_in_year - 1 + highlight_offset, base + perf, "Current Avg: " + str.tostring(perf * 100, format.percent), style = label.style_label_center, textcolor = main_color, size = text_size, color = #ffffff00)
if i == szn_arr.size() - 1
line.new(start_idx, base, start_idx + days_in_year - 1, base, color = main_color, width = 2)
// -------------------- Plotting Functions --------------------
// -------------------- Statistics Table --------------------
var table stats = table.new(table_pos, 50, 50, bgcolor = table_bg, frame_color = table_frame, border_color = table_border, frame_width = 1, border_width = 1)
if barstate.islast
if timeframe.in_seconds() != timeframe.in_seconds("D")
table.cell(stats, 0, 0, "Please Use the 'D' Timeframe")
else
// Sort daily arrays by day --------------------------------------------------
temp_arr_days = arr_days.copy()
for i = temp_arr_days.size() - 1 to 0
min = arr_days.indexof(temp_arr_days.min())
d_sorted_pct.push(d_pct.get(min))
d_sorted_points.push(d_points.get(min))
d_sorted_count.push(d_count.get(min))
d_sorted_day.push(d_day.get(min))
temp_arr_days.set(min, na)
for i = 0 to d_sorted_pct.size() - 1
d_sorted_pct.set(i, d_sorted_pct.get(i) / d_sorted_count.get(i))
d_sorted_points.set(i, d_sorted_points.get(i) / d_sorted_count.get(i))
// Sort daily arrays by day --------------------------------------------------
// Get month performance --------------------------------------------------
m_pct_avg.clear()
for i = 0 to 11
sum = 0.0
for j = 0 to days_in_month - 1
sum += d_sorted_pct.get(i * days_in_month + j)
m_pct_avg.push(sum)
q_pct_avg.clear()
for i = 0 to 3
sum = 0.0
for j = 0 to days_in_qr - 1
sum += d_sorted_pct.get(i * days_in_qr + j)
q_pct_avg.push(sum)
// Get month performance --------------------------------------------------
// Seasonal highs and lows --------------------------------------------------
szn_pct = szn_arr.get(szn_idx)
base = 1.0
var price_projection = array.new_float()
var szn_lows = array.new_string()
var szn_highs = array.new_string()
if szn_pivots
x1 = start_idx
y1 = base
x2 = x1 + 1
for i = 0 to d_pct.size() - 1
price_projection.push(y1)
y2 = y1 * (1 + d_sorted_pct.get(i))
y1 := y2
x1 += 1
x2 += 1
left_bound = pivot_strength
right_bound = price_projection.size() - pivot_strength - 1
for i = left_bound to right_bound
new_low = true
new_high = true
for j = -pivot_strength to pivot_strength
if i != j
if price_projection.get(i) > price_projection.get(i + j)
new_low := false
break
for j = -pivot_strength to pivot_strength
if i != j
if price_projection.get(i) < price_projection.get(i + j)
new_high := false
break
if new_low
new_low_month = get_month(math.ceil(i / days_in_month))
if szn_lows.indexof(new_low_month) == -1
szn_lows.push(new_low_month)
line.new(start_idx + i, base, start_idx + i, base, extend = extend.both, color = low_color, width = pivot_width)
label.new(start_idx + i, math.min(base, base + szn_arr.min()), "SEASONAL\nLOW", color = color.new(low_color, 0), textcolor = main_color, size = text_size, style = label.style_label_up)
if new_high
new_high_month = get_month(math.ceil(i / days_in_month))
if szn_highs.indexof(new_high_month) == -1
szn_highs.push(new_high_month)
line.new(start_idx + i, base, start_idx + i, base, extend = extend.both, color = high_color, width = pivot_width)
label.new(start_idx + i, math.max(base, base + szn_arr.max()), "SEASONAL\nHIGH", color = color.new(high_color, 0), textcolor = main_color, size = text_size, style = label.style_label_down)
// Seasonal highs and lows --------------------------------------------------
// Plotting analysis --------------------------------------------------
dividers(base)
if show_analysis
plot_analysis(period, szn_arr, szn_idx, num_days, base)
// Plotting analysis --------------------------------------------------
// Table --------------------------------------------------
if show_table
curr_month_pct = (m_close - m_open) / m_open
curr_month_points = (m_close - m_open)
table.cell(stats, 0, 0, "Timeframe: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 0, str.tostring(period), text_size = text_size, text_color = table_text)
table.cell(stats, 0, 1, "Collected Over: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 1, str.tostring(year - first_year) + " Years", text_size = text_size, text_color = table_text)
table.cell(stats, 0, 2, "Seasonality: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 2, str.tostring(szn_pct > 0 ? 'BULLISH' : 'BEARISH'), bgcolor = szn_pct > 0 ? upper_color : lower_color, text_size = text_size, text_color = table_text)
table.cell(stats, 0, 3, "Average % Change: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 3, str.tostring(math.round(szn_pct * 10000) / 100, format.percent), bgcolor = szn_pct > 0 ? upper_color : lower_color, text_size = text_size, text_color = table_text)
table.cell(stats, 0, 4, "Current % Change: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 4, str.tostring(math.round(current_pct * 10000) / 100, format.percent), bgcolor = current_pct > 0 ? upper_color : lower_color, text_size = text_size, text_color = table_text)
table.cell(stats, 0, 5, "Current Point Change: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 5, str.tostring(current_pts), bgcolor = current_pts > 0 ? upper_color : lower_color, text_size = text_size, text_color = table_text)
if szn_pivots
table.cell(stats, 0, 6, "Major Lows Made in: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 6, str.tostring(szn_lows), text_size = text_size, text_color = table_text)
table.cell(stats, 0, 7, "Major Highs Made in: ", text_size = text_size, text_color = table_text)
table.cell(stats, 1, 7, str.tostring(szn_highs), text_size = text_size, text_color = table_text)
// Table --------------------------------------------------
// -------------------- Statistics Table -------------------- |
Segment2 | https://www.tradingview.com/script/GxI7sD1z-Segment2/ | RicardoSantos | https://www.tradingview.com/u/RicardoSantos/ | 18 | library | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RicardoSantos
//@version=5
// @description Structure representation of a directed straight line in two dimensions from origin to target vectors.
// .
// reference:
// https://graphics.stanford.edu/courses/cs368/CGAL/ref-manual1/CGAL_Segment_2.html
// .
library(title='Segment2')
//#region ~~~ Imports:
import RicardoSantos/CommonTypesMath/1 as TMath
import RicardoSantos/Vector2/1 as Vector2
//#endregion
//#region -> Constructor:
// new () {
// @function Generate a new segment.
// @param origin Vector2 . Origin of the segment.
// @param target Vector2 . Target of the segment.
// @returns Segment2.
export new (TMath.Vector2 origin, TMath.Vector2 target) =>
TMath.Segment2.new(origin, target)
// @function Generate a new segment.
// @param origin_x float . Origin of the segment x coordinate.
// @param origin_y float . Origin of the segment y coordinate.
// @param target_x float . Target of the segment x coordinate.
// @param target_y float . Target of the segment y coordinate.
// @returns Segment2.
export new (float origin_x, float origin_y, float target_x, float target_y) =>
TMath.Segment2.new(TMath.Vector2.new(origin_x, origin_y), TMath.Vector2.new(target_x, target_y))
// }
// copy () {
// @function Copy a segment.
// @param this Vector2 . Segment to copy.
// @returns Segment2.
export method copy (TMath.Segment2 this) =>
TMath.Segment2.copy(this)
// }
//#endregion
//#region -> Methods:
//#region -> Properties:
// length_squared () {
// @function Squared length of the normalized segment vector. For comparing vectors this is computationaly lighter.
// @param this Segment2 . Sorce segment.
// @returns float.
export method length_squared (TMath.Segment2 this) =>
Vector2.length_squared(this.target.subtract(this.origin))
// }
// length () {
// @function Length of the normalized segment vector.
// @param this Segment2 . Sorce segment.
// @returns float.
export method length (TMath.Segment2 this) =>
Vector2.length(this.target.subtract(this.origin))
// }
// opposite () {
// @function Reverse the direction of the segment.
// @param this Segment2 . Source segment.
// @returns Segment2.
export method opposite (TMath.Segment2 this) =>
new(this.target, this.origin)
// }
// is_degenerate () {
// @function Segment is degenerate when origin and target are equal.
// @param this Segment2 . Source segment.
// @returns bool.
export method is_degenerate (TMath.Segment2 this) =>
this.origin.x == this.target.x and this.origin.y == this.target.y
// }
// is_horizontal () {
// @function Segment is horizontal?.
// @param this Segment2 . Source segment.
// @returns bool.
export method is_horizontal (TMath.Segment2 this) =>
this.origin.y == this.target.y
// @function Segment is horizontal?.
// @param this Segment2 . Source segment.
// @param precision float . Limit of precision.
// @returns bool.
export method is_horizontal (TMath.Segment2 this, float precision) =>
math.abs(this.origin.y - this.target.y) <= precision
// }
// is_vertical () {
// @function Segment is vertical?.
// @param this Segment2 . Source segment.
// @returns bool.
export method is_vertical (TMath.Segment2 this) =>
this.origin.x == this.target.x
// @function Segment is vertical?.
// @param this Segment2 . Source segment.
// @param precision float . Limit of precision.
// @returns bool.
export method is_vertical (TMath.Segment2 this, float precision) =>
math.abs(this.origin.x - this.target.x) <= precision
// }
//#endregion
//#region -> Functions:
// equals () {
// @function Tests two segments for equality (share same origin and target).
// @param this Segment2 . Source segment.
// @param other Segment2 . Target segment.
// @returns bool.
export method equals (TMath.Segment2 this, TMath.Segment2 other) =>
this.origin.equals(other.origin) and this.target.equals(other.target)
// }
// nearest_to_point () {
// reference:
// https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/math/Intersector.java
// @function Find the nearest point in a segment to another point.
// @param this Segment2 . Source segment.
// @param point Vector2 . Point to aproximate.
// @returns Vector2.
export method nearest_to_point (TMath.Segment2 this, TMath.Vector2 point) =>
float _dx = this.target.x - this.origin.x
float _dy = this.target.y - this.origin.y
float _length = _dx * _dx + _dy * _dy
if _length == 0.0
this.origin
else
float _t = ((point.x - this.origin.x) * _dx + (point.y - this.origin.y) * _dy) / _length
switch
_t <= 0.0 => this.origin
_t >= 1.0 => this.target
=> Vector2.lerp(this.origin, this.target, _t)
// TEST: OK 20230216 RS
// position = input.int(10)
// p = Vector2.new(float(bar_index+position), 10.0)
// L1 = new(bar_index+10.0, 10.0, bar_index+100.0, 20.0)
// if barstate.islast
// _p1 = L1.nearest_to_point(p)
// line.new(int(L1.origin.x), L1.origin.y, int(L1.target.x), L1.target.y, xloc.bar_index, extend.none, #e3e3e3, line.style_arrow_right)
// label.new(int(p.x), p.y, 'P', color=#e3e3e3, style=label.style_label_center)
// label.new(int(_p1.x), _p1.y, 'X', color=#e3e3e3, style=label.style_label_center)
// }
// intersection () {
// @function Find the intersection vector of 2 lines.
// @param this Segment2 . Segment A.
// @param other Segment2 . Segment B.
// @returns Vector2.Vector2 Object.
export method intersection (TMath.Segment2 this, TMath.Segment2 other) =>
float _a1 = this.target.y - this.origin.y
float _b1 = this.origin.x - this.target.x
float _c1 = _a1 * this.origin.x + _b1 * this.origin.y
float _a2 = other.target.y - other.origin.y
float _b2 = other.origin.x - other.target.x
float _c2 = _a2 * other.origin.x + _b2 * other.origin.y
float _delta = _a1 * _b2 - _a2 * _b1
Vector2.new((_b2 * _c1 - _b1 * _c2) / _delta, (_a1 * _c2 - _a2 * _c1) / _delta)
// TEST: OK 20230216 RS
// L1 = new(bar_index+10.0, 10.0, bar_index+20.0, 20.0)
// L2 = new(bar_index+10.0, 40.0, bar_index+20.0, 30.0)
// if barstate.islast
// _intersect = L1.intersection(L2)
// line.new(int(L1.origin.x), L1.origin.y, int(L1.target.x), L1.target.y, xloc.bar_index, extend.none, #e3e3e3, line.style_arrow_right)
// line.new(int(L2.origin.x), L2.origin.y, int(L2.target.x), L2.target.y, xloc.bar_index, extend.none, #e3e3e3, line.style_arrow_right)
// label.new(int(_intersect.x), _intersect.y, 'X', color=#e3e3e3, style=label.style_label_center)
// }
// extend () {
// @function Extend a segment by the percent ratio provided.
// @param this Segment2 . Source segment.
// @param at_origin float . Percent ratio to extend at origin vector.
// @param at_target float . Percent ratio to extend at target vector.
// @returns Segment2.
export method extend (TMath.Segment2 this, float at_origin=0.0, float at_target=0.0) =>
float _dx = this.target.x - this.origin.x
float _dy = this.target.y - this.origin.y
new(
this.origin.x - _dx * at_origin ,
this.origin.y - _dy * at_origin ,
this.target.x + _dx * at_target ,
this.target.y + _dy * at_target )
// TEST: 20230217 RS
// ratio_at_origin = input.float(0.0)
// ratio_at_target = input.float(0.0)
// if barstate.islast
// _s = new(bar_index+5.0, 10.0, bar_index+20.0, 30.0).extend(ratio_at_origin, ratio_at_target)
// line.new(int(_s.origin.x), _s.origin.y, int(_s.target.x), _s.target.y)
// }
//#endregion
//#region -> Translation:
// to_string () {
// @function Translate segment to string format `( (x,y), (x,y) )`.
// @param this Segment2 . Source segment.
// @returns string.
export method to_string (TMath.Segment2 this) =>
str.format('( {0} , {1})', this.origin.to_string(), this.target.to_string())
// @function Translate segment to string format `((x,y), (x,y))`.
// @param this Segment2 . Source segment.
// @param format string . Format string to apply.
// @returns string.
export method to_string (TMath.Segment2 this, string format) =>
str.format('( {0}, {1} )', this.origin.to_string(format), this.target.to_string(format))
// }
// to_array () {
// @function Translate segment to array format.
// @param this Segment2 . Source segment.
// @returns array<float>.
export method to_array (TMath.Segment2 this) =>
array.from(float(this.origin.x), float(this.origin.y), float(this.target.x), float(this.target.y))
// }
//#endregion
//#endregion
|
BankNifty targets using VIX Version 2 | https://www.tradingview.com/script/RQF0tlIX-BankNifty-targets-using-VIX-Version-2/ | nanujogi | https://www.tradingview.com/u/nanujogi/ | 128 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © nanujogi.
// Credit: cusomFonts thanks flies to kaigouthro.
// https://www.tradingview.com/script/vmuJYczR-font/
//@version=5
MAXLABELS = 125
indicator("BankNifty targets using VIX Version 2", shorttitle = "VIX", overlay = true, max_bars_back = MAXLABELS, max_labels_count = MAXLABELS)
import kaigouthro/font/5 as customFonts
// STEP 1. Make an input with drop-down menu
sizeOption = input.string(defval="Normal", title="Font Size", options=["Auto", "Huge", "Large", "Normal", "Small", "Tiny"], tooltip = "Select your font size")
// STEP 2. Convert the input to valid label sizes
labelSize = (sizeOption == "Huge") ? size.huge :
(sizeOption == "Large") ? size.large :
(sizeOption == "Small") ? size.small :
(sizeOption == "Tiny") ? size.tiny :
(sizeOption == "Auto") ? size.auto :
size.normal
FontOption = input.string(defval="Default", title="Select Fonts", options=["Sans", "Sans Italic", "Sans Bold", "Sans Bold Italic", "Sans-Serif", "Sans-Serif Italic", "Sans-Serif Bold", "Sans-Serif Bold Italic",
"Fraktur", "Fraktur Bold",
"Script", "Script Bold",
"Double-Struck",
"Monospace",
"Regional Indicator",
"Small",
"Full Width",
"Circled",
"Default"], tooltip = "Select your font")
FontSelected = (FontOption == "Sans") ? 1 :
(FontOption == "Sans Italic") ? 2 :
(FontOption == "Sans Bold") ? 3 :
(FontOption == "Sans Bold Italic") ? 4 :
(FontOption == "Sans-Serif") ? 5 :
(FontOption == "Sans-Serif Italic") ? 6 :
(FontOption == "Sans-Serif Bold") ? 7 :
(FontOption == "Sans-Serif Bold Italic") ? 8 :
(FontOption == "Fraktur") ? 9 :
(FontOption == "Fraktur Bold") ? 10 :
(FontOption == "Script") ? 11 :
(FontOption == "Script Bold") ? 12 :
(FontOption == "Double-Struck") ? 13 :
(FontOption == "Monospace") ? 14 :
(FontOption == "Regional Indicator") ? 15 :
(FontOption == "Small") ? 16 :
(FontOption == "Full Width") ? 17 :
(FontOption == "Circled") ? 18 :
3 // Default
/// Static Strings used in Table using HardCode Font Sans Bold i.e. Default
str_Index = "Index"
str_BankNifty = "BankNifty"
str_Nifty = "Nifty"
str_Daily_High_and_Low = "Daily High & Low"
str_Weekly_High_and_Low = "Weekly High & Low"
str_Monthly_High_and_Low = "Monthly High & Low"
str_Yearly_High_and_Low = "Yearly High & Low"
str_H = "H"
str_L = "L"
str_Basis = "Basis"
str_Basis_Current = "Current"
str_Basis_High = "High"
str_Basis_Low = "Low"
str_percentage_Left = "% Left"
str_dottedLines = "‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒‒"
str_Abbrevation = "𝗩𝗛 = VIX High\n" +
"\𝗛 > 𝗩𝗛𝗗 = High is greater than VIX High Difference meaning how many points higher it went above VIX High.\n" +
"\𝗛𝗗% = High Difference in % (Percentage)\n" +
str_dottedLines +
"\n𝗩 = VIX Current INDIA VIX\n" + "𝗩𝗗 = VIX Difference in points\n" + "𝗩𝗗% = VIX Difference in % (Percentage)\n" +
str_dottedLines +
"\n𝗛𝗕𝗗 = High Basis Difference i.e. When High was being Made in Spot the Future price difference is shown.\n" +
"\𝗕𝗟 = Basis Low i.e. When Low was made Basis difference is shown.\n" + "𝗕𝗖 = Basis Close\n" +
str_dottedLines +
"𝗩𝗟 = VIX Low\n" +
"\𝗟 < 𝗩𝗟𝗗 = Low is less then VIX Low meaning how many points lower it went below VIX Low.\n" +
"\𝗟𝗗% = Low Difference in % (Percentage)\n"
color_for_higher_then_average = color.aqua
color AvgHigh_VixHigh_color = na
color AvgHigh_VixLow_color = na
color AvgLow_VixHigh_color = na
color AvgLow_VixLow_color = na
color Txt_Color_AvgHigh_VixHigh = na
color Txt_Color_AvgHigh_VixLow = na
color Txt_Color_AvgLow_VixHigh = na
color Txt_Color_AvgLow_VixLow = na
// strtooltipVixHigh = "\n\nV\nI\nX\n\nH\nI\nG\nH"
// strtooltipVixLow = "\n\nV\nI\nX\n\nL\nO\nW"
show_Averages = input.bool(true, "Show Averages of High & Low") // Show averages
show_vix = input.bool(true, "Show Vix") // Show VIX
show_Vix_calculated_high = input.bool(true, "Show calculated VIX High", tooltip = "Show calculated VIX High for the current Day") // Show calculated VIX High for the current Day
show_Vix_calculated_low = input.bool(true, "Show calculated VIX Low ", tooltip = "Show calculated VIX Low for the current Day")
show_previous_day_vix_high = input.bool(true, "Show Previous Day Vix High", tooltip = "Show previous day calculated VIX High")
show_previous_day_vix_low = input.bool(true, "Show Previous Day Vix Low ", tooltip = "Show previous day calculated VIX Low")
show_Table = input.bool(true, "Show Table", tooltip = "Show calculated Table") // Show calculated Table
show_NiftyVIX = input.bool(false, "Show Nifty VIX", tooltip = "Select this if you need to see Nifty VIX inside table")
show_data_inToolTip = input.bool(false, "Show data in Tool Tip", tooltip = "Select this if you need to Data as ToolTip so there is less clutter on screen")
DtimeFrame = math.sqrt(365) // 19.10 approx values
WtimeFrame = math.sqrt(52) // 7.21 approx values
MtimeFrame = math.sqrt(12) // 3.16 approx values
YtimeFrame = math.sqrt(1)
bndHighReached = false
bndLowReached = false
isit_BankNifty = false
if ticker.standard() == "NSE:BANKNIFTY"
isit_BankNifty := true
//// Implemented Day Time Frame checks. Now will show an Yellow Box in Middle if user is has selected One Hour Time Frame.
/// Thanks flies out to BobRivera990 for shareing source code of Weekly Volume Heatmap.
var string show_user_correct_timeframe = "Please use Day Time Frame on BankNifty Spot !!!"
var string msg_user_to_select_BankNifty = "Please select BankNifty Spot !!!"
var bool correct_TimeFrame = timeframe.multiplier == 1
var table dialogBox = table.new(position.middle_center, 1, 1, bgcolor = color.yellow)
showDialog(_dialogBox, _msg) =>
table.cell(_dialogBox, 0, 0, _msg, text_color = color.red, text_size = size.large)
// if not correct_TimeFrame
// showDialog(dialogBox, show_user_correct_timeframe)
if not isit_BankNifty
showDialog(dialogBox, msg_user_to_select_BankNifty)
[vixDaily, pdayVix, vixClose] = request.security("NSE:INDIAVIX", "D", [close, close[1], close])
[niftyDaily, ndHigh, ndLow, ndPHigh, ndPLow, npClose] = request.security("NSE:NIFTY", "D", [close, high, low, high[1], low[1], close[1]])
[bankniftyDaily, bndHigh, bndLow, bndPHigh, bndPLow,bnpClose] = request.security("NSE:BANKNIFTY", "D", [close, high, low, high[1], low[1], close[1]])
// For Basis calculation we need Future Price
[futureBNclose, futureBNHigh, futureBNLow] = request.security("NSE:BANKNIFTY1!", "D", [close, high, low])
niftyWeekly = request.security("NSE:NIFTY", "W", close)
bankniftyWeekly = request.security("NSE:BANKNIFTY", "W", close)
niftyMonthly = request.security("NSE:NIFTY", "M", close)
bankniftyMonthly = request.security("NSE:BANKNIFTY", "M", close)
niftyYearly = request.security("NSE:NIFTY", "365", close)
bankniftyYearly = request.security("NSE:BANKNIFTY", "365", close)
string tableYposInput = input.string("top", "Table position", inline = "11", options = ["top", "middle", "bottom"])
string tableXposInput = input.string("right", "", inline = "11", options = ["left", "center", "right"])
dRange = vixDaily / DtimeFrame
wRange = vixDaily / WtimeFrame
mRange = vixDaily / MtimeFrame
yRange = vixDaily /YtimeFrame
// Secret Calculation 😄
vixdNiftyHigh = niftyDaily + ((niftyDaily * dRange)/100)
vixdNiftyLow = niftyDaily - ((niftyDaily * dRange)/100)
vixwNiftyHigh = niftyWeekly + ((niftyWeekly * wRange)/100)
vixwNiftyLow = niftyWeekly - ((niftyWeekly * wRange)/100)
mNiftyHigh = niftyMonthly + ((niftyMonthly * mRange)/100)
mNiftyLow = niftyMonthly - ((niftyMonthly * mRange)/100)
yNiftyHigh = niftyYearly + ((niftyYearly * yRange)/100)
yNiftyLow = niftyYearly - ((niftyYearly * yRange)/100)
vixdBankNiftyHigh = bankniftyDaily + ((bankniftyDaily * dRange)/100)
vixdBankNiftyLow = bankniftyDaily - ((bankniftyDaily * dRange)/100)
wBankNiftyHigh = bankniftyWeekly + ((bankniftyWeekly * wRange)/100)
wBankNiftyLow = bankniftyWeekly - ((bankniftyWeekly * wRange)/100)
mBankNiftyHigh = bankniftyMonthly + ((bankniftyMonthly * mRange)/100)
mBankNiftyLow = bankniftyMonthly - ((bankniftyMonthly * mRange)/100)
yBankNiftyHigh = bankniftyYearly + ((niftyYearly * yRange)/100)
yBankNiftyLow = bankniftyYearly - ((niftyYearly * yRange)/100)
// Let's Plot them.
plot(show_vix ? vixDaily : na, color=color.yellow, title="India VIX")
plot(show_Vix_calculated_high ? vixdBankNiftyHigh : na, title="Nifty Daily High", color=color.green)
plot(show_Vix_calculated_low ? vixdBankNiftyLow : na, title ="Nifty Daily Low", color=color.red)
// Calculation for how far is the targets of Daily, Weekly, Monthly and Yearly.
how_far_is_high_and_low_daily = (vixdBankNiftyHigh * 100 / bankniftyDaily) - 100
how_far_is_high_and_low_weekly = (wBankNiftyHigh * 100 / bankniftyDaily) - 100
how_far_is_high_and_low_monthly = (mBankNiftyHigh * 100 / bankniftyDaily)- 100
how_far_is_high_and_low_yearly = (yBankNiftyHigh * 100 / bankniftyDaily) - 100
basisHigh = futureBNHigh - bndHigh // difference between Future High - Spot High = Basis
basisclose = futureBNclose - bankniftyDaily // difference between Future Close - Spot Close = Closing Basis Difference
basisLow = futureBNLow - bndLow // difference between Future Low - Spot Low = Low Basis Difference
var table vixTable = table.new(tableYposInput + "_" + tableXposInput, columns=5, rows=5, border_color = color.white, frame_color = color.white, frame_width = 1, border_width = 1)
if barstate.islast and show_Table // You can disable the table on screen if required.
// We only populate the table on the last bar.
table.cell(vixTable, 0, 0, text=customFonts.uni(str_Index, 3), text_color = color.rgb(210,219,35), text_halign = text.align_center, text_size = size.normal, bgcolor = color.black, tooltip="Daily EMA")
table.cell(vixTable, 1, 0, text=customFonts.uni(str_Daily_High_and_Low, 3), text_color = color.rgb(210,219,35), text_halign = text.align_center, text_size = size.normal, bgcolor = color.black, tooltip="Daily High & Low")
table.cell(vixTable, 2, 0, text=customFonts.uni(str_Weekly_High_and_Low, 3), text_color = color.rgb(210,219,35), text_halign = text.align_center, text_size = size.normal, bgcolor = color.black, tooltip="Weekly High & Low")
table.cell(vixTable, 3, 0, text=customFonts.uni(str_Monthly_High_and_Low, 3), text_color = color.rgb(210,219,35), text_halign = text.align_center, text_size = size.normal, bgcolor = color.black, tooltip="Monthly High & Low ")
table.cell(vixTable, 4, 0, text=customFonts.uni(str_Yearly_High_and_Low, 3), text_color = color.rgb(210,219,35), text_halign = text.align_center, text_size = size.normal, bgcolor = color.black, tooltip="Yearly High & Low")
if show_NiftyVIX
table.cell(vixTable, 0, 1, text=customFonts.uni(str_Nifty, 3), text_color=color.rgb(210,219,35), text_size = size.normal, bgcolor = color.black)
table.cell(vixTable, 1, 1, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", vixdNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", vixdNiftyLow), text_color = #00A2ED)
table.cell(vixTable, 2, 1, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", vixwNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", vixwNiftyLow), text_color = color.lime)
table.cell(vixTable, 3, 1, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", mNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", mNiftyLow), text_color = color.orange)
table.cell(vixTable, 4, 1, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", yNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", yNiftyLow), text_color = color.green)
table.cell(vixTable, 0, 2, text=customFonts.uni(str_BankNifty, 3), text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 1, 2, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", vixdBankNiftyHigh) +"\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", vixdBankNiftyLow), text_color = #00A2ED)
table.cell(vixTable, 2, 2, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", wBankNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", wBankNiftyLow), text_color = color.lime)
table.cell(vixTable, 3, 2, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", mBankNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", mBankNiftyLow), text_color = color.orange)
table.cell(vixTable, 4, 2, text_halign = text.align_center, text_size = size.normal, text = customFonts.uni(str_H, 3) + str.format("{0, number, #.##}", yBankNiftyHigh) + "\n" + customFonts.uni(str_L, 3) + " " + str.format("{0, number, #.##}", yBankNiftyLow), text_color = color.green)
table.cell(vixTable, 0, 3, text=customFonts.uni(str_percentage_Left, 3), text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 1, 3, text= " ⦿ " + str.format("{0, number, #.####}", how_far_is_high_and_low_daily) + "%", text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 2, 3, text= " ⦿ " + str.format("{0, number, #.##}", how_far_is_high_and_low_weekly) + "%", text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 3, 3, text= " ⦿ " + str.format("{0, number, #.####}", how_far_is_high_and_low_monthly) + "%", text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 4, 3, text= " ⦿ " + str.format("{0, number, #.##}", how_far_is_high_and_low_yearly) + "%", text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black)
table.cell(vixTable, 0, 4, text= customFonts.uni(str_Basis, 3), text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black, tooltip = str_Abbrevation)
table.cell(vixTable, 1, 4, text= " " + customFonts.uni(str_Basis_Current, 3) + str.format("{0, number, #.##}", basisclose) + " ⦿ " +
customFonts.uni(str_Basis_High, 3) + str.format("{0, number, #.##}", basisHigh) + " ⦿ " +
customFonts.uni(str_Basis_Low, 3) + str.format("{0, number, #.##}", basisLow),
text_color=color.rgb(210,219,35), text_size = size.normal,bgcolor = color.black, text_halign=text.align_left)
table.merge_cells(vixTable,1,4,4,4)
pdRange = pdayVix / DtimeFrame
PvixdbnHigh = bnpClose + ((bnpClose * pdRange)/100)
PvixdbnLow = bnpClose - ((bnpClose * pdRange)/100)
bndHighReached := bndHigh > PvixdbnHigh
bndLowReached := bndLow < PvixdbnLow
plot(show_previous_day_vix_high ? PvixdbnHigh : na, color=color.white, title = "Previous Day High")
plot(show_previous_day_vix_low ? PvixdbnLow : na ,color = color.white, title = "Previous Day Low")
// % calculation. How higher it went from previous day calculated high price.
get_high_difference = bndHigh - PvixdbnHigh
high_percentage_calculation = ((bndHigh * 100) / PvixdbnHigh) - 100
// // % calculation. How low it went from previous day calculated high price.
get_low_difference = bndLow - PvixdbnLow
low_percentage_calculation = ((bndLow * 100) / PvixdbnLow) - 100
// Date: 09-07-2023 added this option to show Averages of % High and % Low BankNifty went above VIX High and VIX Low
///// Show Averages STARTS:
/// Whenever and VIX High or VIX Low is reached we are saving in an array the % of BankNifty went above or below VIX High or VIX Low.
// We then use array.avg inbuilt function to dislpay the averages.
var high_Percent_Array = array.new_float(0)
var low_Percent_Array = array.new_float(0)
if bndHighReached
array.push(high_Percent_Array, math.round(high_percentage_calculation, 2))
if bndLowReached
array.push(low_Percent_Array, math.round(low_percentage_calculation, 2))
/// Show Averages ENDS
// calculation of VIX difference & percentage
vix_difference = vixClose - pdayVix // pdayVix = Previous Day Vix
vix_perecentage = ((vixClose * 100) / pdayVix) - 100
show_vix_upArrow = vixClose > pdayVix
show_vix_downArrow = vixClose < pdayVix
// Logs incorporated for Study date 31-08-2023
if bndHighReached
log.warning ("BankNifty went Above \n
Calculated VIX High was {0,number,#.##}\n
High it went {1, number, #.##} it was {2, number, #.##} points higher the VIX High\n
High Difference in (%) : {3, number, #.##}(%) \n
VIX is : {4, number, #.##} Basis : {5, number, #.##}", PvixdbnHigh, bndHigh, get_high_difference, high_percentage_calculation, vixDaily, basisclose)
if bndLowReached
log.info ("BankNifty went Below \n
Calculated VIX Low was {0,number,#.##}\n
Low it went {1, number, #.##} it was {2, number, #.##} points higher the VIX Low\n
Low Difference in (%) : {3, number, #.##}(%) \n
VIX is : {4, number, #.##} Basis : {5, number, #.##}", PvixdbnLow, bndLow, get_low_difference, low_percentage_calculation, vixDaily, basisclose)
showStr_avg_High = show_Averages ? "\n\nAvg. High : " + str.format("{0, number, #.##}", array.avg(high_Percent_Array)) : " "
showStr_avg_Low = show_Averages ? "\n\nAvg Low : " + str.format("{0, number, #.##}", array.avg(low_Percent_Array)) : " "
// Presentation Matters 😄
str_vix_High_upArrow = "VH:" + str.format("{0, number, #.##}", PvixdbnHigh) +"" + "\n" + "H>HVD: " +
str.format("{0, number, #.##}", get_high_difference) + "⬆" + "\n" + "HD% : " + str.format("{0, number, #.##}", high_percentage_calculation)+"%"+
"\n\nV: " + str.format("{0, number, #.##}", vixDaily) + " ⦿ VD: " + str.format("{0, number, #.####}", vix_difference) + "⬆" +
"\nVD%: " + str.format("{0, number, #.##}", vix_perecentage)+"%" + // str_formatHighTime +
"\nHBD: " + str.format("{0, number, #.##}", basisHigh) +
" ⦿ BL: " + str.format("{0, number, #.##}", basisLow) +
"\nBC: " + str.format("{0, number, #.##}", basisclose) + showStr_avg_High
str_vix_High_downArrow = "VH:" + str.format("{0, number, #.##}", PvixdbnHigh) +"" + "\n" + "H>VHD: " +
str.format("{0, number, #.##}", get_high_difference) + "⬆" + "\n" + "HD% : " + str.format("{0, number, #.##}", high_percentage_calculation)+"%"+
"\n\nV: " + str.format("{0, number, #.##}", vixDaily) + " ⦿ VD: " + str.format("{0, number, #.####}", vix_difference) + "⬇" +
"\nVD%: " + str.format("{0, number, #.##}", vix_perecentage)+"%"+ // str_formatHighTime +
"\nHBD: " + str.format("{0, number, #.##}", basisHigh) +
" ⦿ BL: " + str.format("{0, number, #.##}", basisLow) +
"\nBC: " + str.format("{0, number, #.##}", basisclose) + showStr_avg_High
// Colors when Vix High % is more then Average Price
AvgHigh_VixHigh_color := high_percentage_calculation > array.avg(high_Percent_Array) ? #0A3161 : #014421
AvgHigh_VixLow_color := high_percentage_calculation > array.avg(high_Percent_Array) ? #0A3161 : #DFFE0D
Txt_Color_AvgHigh_VixHigh := high_percentage_calculation > array.avg(high_Percent_Array) ? color.white : #FADA5E
Txt_Color_AvgHigh_VixLow := high_percentage_calculation > array.avg(high_Percent_Array) ? color.white : color.black
// Showing data inside ToolTip.
if show_vix_upArrow and bndHighReached and show_data_inToolTip
label.new(bar_index, na, color = AvgHigh_VixHigh_color, style=label.style_label_down,text="VIX HIGH", //customFonts.uni(strtooltipVixHigh, FontSelected) ,
// label.new(bar_index, na, color = #014421, style=label.style_label_down,text="V\nI\nX\n\nH\nI\nG\nH", //customFonts.uni(strtooltipVixHigh, FontSelected) ,
textcolor = Txt_Color_AvgHigh_VixHigh, textalign = text.align_center, size = labelSize, yloc = yloc.abovebar, text_font_family = font.family_default, tooltip = str_vix_High_upArrow)
else if show_vix_downArrow and bndHighReached and show_data_inToolTip
label.new(bar_index, na, color = AvgHigh_VixLow_color, style=label.style_label_down,text="VIX HIGH",// customFonts.uni(strtooltipVixHigh, FontSelected),
// label.new(bar_index, na, color = #DFFE0D, style=label.style_label_down,text="V\nI\nX\n\nH\nI\nG\nH",// customFonts.uni(strtooltipVixHigh, FontSelected),
textcolor = Txt_Color_AvgHigh_VixLow, textalign = text.align_center, size = labelSize, yloc = yloc.abovebar, text_font_family = font.family_default, tooltip = str_vix_High_downArrow)
// ORIGINAL
if show_vix_upArrow and bndHighReached and not show_data_inToolTip
label.new(bar_index, na, color = AvgHigh_VixHigh_color, style=label.style_label_down,text=customFonts.uni(str_vix_High_upArrow, FontSelected),
textcolor = Txt_Color_AvgHigh_VixHigh, textalign = text.align_center, size = labelSize, yloc = yloc.abovebar, text_font_family = font.family_default)
else if show_vix_downArrow and bndHighReached and not show_data_inToolTip
label.new(bar_index, na, color = AvgHigh_VixLow_color, style=label.style_label_down,text=customFonts.uni(str_vix_High_downArrow, FontSelected),
textcolor = Txt_Color_AvgHigh_VixLow, textalign = text.align_center, size = labelSize, yloc = yloc.abovebar, text_font_family = font.family_default)
// String formating for showing VIX Low with upArrow for customFonts Library. VIX is higher then previous day hence upArrow
str_vix_low_upArrow = "VL: " + str.format("{0, number, #.##}", PvixdbnLow)+"" + "\n" + "L<VLD: " +
str.format("{0, number, #.##}", get_low_difference) + "⬇" + "\n" + "LD%: " + str.format("{0, number, #.##}", low_percentage_calculation)+"%"+
"\n\nV: " + str.format("{0, number, #.##}", vixDaily) + " ⦿ VD: " + str.format("{0, number, #.####}", vix_difference) + "⬆" +
"\nVD%: " + str.format("{0, number, #.##}", vix_perecentage)+"%" +
"\nHBD: " + str.format("{0, number, #.##}", basisHigh) +
" ⦿ BL: " + str.format("{0, number, #.##}", basisLow) +
"\nBC: " + str.format("{0, number, #.##}", basisclose) + showStr_avg_Low
// String formating for showing VIX Low with Down Arrow for customFonts Library. VIX is Lower then previous day hence downArrow.
str_vix_low_downArrow = "VL:" + str.format("{0, number, #.##}", PvixdbnLow) + "" + "\n" + "L<VLD: " +
str.format("{0, number, #.##}", get_low_difference) + "⬇" + "\n" + "LD% : " + str.format("{0, number, #.##}", low_percentage_calculation)+"%"+
"\n\nV: " + str.format("{0, number, #.##}", vixDaily) + " ⦿ VD: " + str.format("{0, number, #.####}", vix_difference) + "⬇" +
"\nV%: " + str.format("{0, number, #.##}", vix_perecentage)+"%" +
"\nHBD: " + str.format("{0, number, #.##}", basisHigh) +
" ⦿ BL: " + str.format("{0, number, #.##}", basisLow) +
"\nBC: " + str.format("{0, number, #.##}", basisclose) + showStr_avg_Low
// Colors when Vix Low > Average VIX Low %
AvgLow_VixHigh_color := low_percentage_calculation < array.avg(low_Percent_Array) ? #fe1493 : #8b0000
AvgLow_VixLow_color := low_percentage_calculation < array.avg(low_Percent_Array) ? #fe1493 : #D31A38 //
if bndLowReached and show_vix_upArrow and show_data_inToolTip
label.new(bar_index, na, color = AvgLow_VixHigh_color, style=label.style_label_up,text="VIX LOW", // customFonts.uni(strtooltipVixLow, FontSelected),
// label.new(bar_index, na, color = #8b0000, style=label.style_label_up,text="V\nI\nX\n\nL\nO\nW",// customFonts.uni(strtooltipVixLow, FontSelected),
textcolor = color.white, textalign = text.align_center, size = labelSize, yloc = yloc.belowbar, text_font_family = font.family_default, tooltip = str_vix_low_upArrow)
else if bndLowReached and show_vix_downArrow and show_data_inToolTip
label.new(bar_index, na, color = AvgLow_VixLow_color, style=label.style_label_up,text="VIX LOW", // customFonts.uni(strtooltipVixLow, FontSelected),
// label.new(bar_index, na, color = #D31A38, style=label.style_label_up,text="V\nI\nX\n\nL\nO\nW", // customFonts.uni(strtooltipVixLow, FontSelected),
textcolor = color.white, textalign = text.align_center, size = labelSize, yloc = yloc.belowbar, text_font_family = font.family_default, tooltip = str_vix_low_downArrow)
if bndLowReached and show_vix_upArrow and not show_data_inToolTip
label.new(bar_index, na, color = AvgLow_VixHigh_color, style=label.style_label_up,text=customFonts.uni(str_vix_low_upArrow, FontSelected),
textcolor = color.white, textalign = text.align_center, size = labelSize, yloc = yloc.belowbar, text_font_family = font.family_default)
else if bndLowReached and show_vix_downArrow and not show_data_inToolTip
label.new(bar_index, na, color = AvgLow_VixLow_color, style=label.style_label_up,text=customFonts.uni(str_vix_low_downArrow, FontSelected),
textcolor = color.white, textalign = text.align_center, size = labelSize, yloc = yloc.belowbar, text_font_family = font.family_default)
// Variable for Alerts was an brain storming exercise how to implement frequence all option in Alerts. Enjoy 😄
varip close_above_PvixdbnHigh = bool(na)
varip close_below_PvixdbnHigh = bool(na)
varip close_below_PvixdbnLow = bool(na)
varip close_above_PvixdbnLow = bool(na)
varip a_hightarget = false
varip a_lowtarget = false
close_above_PvixdbnHigh := close > math.round(PvixdbnHigh) // CMP greater then calculated Vix High
// Once the price goes above Previous Day calculated High we set an condition true or false
close_below_PvixdbnHigh := close < math.round(PvixdbnHigh) // CMP going below calculated Vix High
// Once the price goes below Previous Day calculated High we set an condition true or false
// Similarly below when price goes below Previous Day Calculated Low we set and condition and when the price goes above the Low we set an condition.
close_below_PvixdbnLow := close < math.round(PvixdbnLow) //
close_above_PvixdbnLow := close > math.round(PvixdbnLow) //
// ❗️ Note : Alerts for Target Reached (High or Low) : Alerts are with frequence all means as many times the prices goes up and down you'll get the alerts continously.
// at times it will be disable automatically so you need to reset it manually.
if a_hightarget and close_above_PvixdbnHigh
a_hightarget := false
alert(syminfo.tickerid + " ▲ CMP is Going UP than VIX HIGH : " + str.format("{0, number, #.##}", PvixdbnHigh) + " ▲ " +
" TF = (" + timeframe.period + ") " + str.format_time(timenow, "dd-MM-yyyy HH:mm:ss", syminfo.timezone), alert.freq_all)
if a_hightarget == false and close_below_PvixdbnHigh
a_hightarget := true
alert(syminfo.tickerid + " ▼ CMP is going Down below VIX HIGH : " + str.format("{0, number, #.##}", PvixdbnHigh) + " ▼ " +
" TF = (" + timeframe.period + ") " + str.format_time(timenow, "dd-MM-yyyy HH:mm:ss", syminfo.timezone), alert.freq_all)
// Alerts for Low Target Reached
if a_lowtarget and close_below_PvixdbnLow
a_lowtarget := false
alert(syminfo.tickerid + " ▼ CMP is Going down below VIX LOW : " + str.format("{0, number, #.##}", PvixdbnLow) + " ▼ " +
" TF = (" + timeframe.period + ") " + str.format_time(timenow, "dd-MM-yyyy HH:mm:ss", syminfo.timezone), alert.freq_all)
if a_lowtarget == false and close_above_PvixdbnLow
a_lowtarget := true
alert(syminfo.tickerid + " ▲ CMP is going UP above VIX LOW : " + str.format("{0, number, #.##}", PvixdbnLow) + " ▲ " +
" TF = (" + timeframe.period + ") " + str.format_time(timenow, "dd-MM-yyyy HH:mm:ss", syminfo.timezone), alert.freq_all)
|
Dominant Period-Based Moving Average (DPBMA) | https://www.tradingview.com/script/zHYDgMzv-Dominant-Period-Based-Moving-Average-DPBMA/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 50 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("My script", overlay = true)
import lastguru/DominantCycle/2 as d
ema(float source = close, float length = 9)=>
alpha = 2 / (length + 1)
var float smoothed = na
smoothed := alpha * source + (1 - alpha) * nz(smoothed[1])
source = input.source(close, "Source")
harmonic = input.int(1, "Length", 1)
length(source, harmonic)=>
cycle = math.round(d.mamaPeriod(source, 1, 2048))
var cycles = array.new<float>(1)
var count_cycles = array.new<int>(1)
if not array.includes(cycles, cycle)
array.push(cycles, cycle)
array.push(count_cycles, 1)
else
index = array.indexof(cycles, cycle)
array.set(count_cycles, index, array.get(count_cycles, index) + 1)
max_index = array.indexof(count_cycles, array.max(count_cycles))
max_cycle = array.get(cycles, max_index) * harmonic
length = length(source, harmonic)
aema = ema(source, length)
plot(aema) |
Simple Moving Average Extrapolation via Monte Carlo (SMAE) | https://www.tradingview.com/script/SC3d1cEZ-Simple-Moving-Average-Extrapolation-via-Monte-Carlo-SMAE/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 49 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("SMAE", overlay = true, max_lines_count = 500)
logReturn(a, b)=>
math.log(a / b) * 100
addLogReturn(number, logReturn) =>
result = number * math.exp(logReturn / 100)
result
movement_probability(source, accuracy)=>
var movement_size_green = array.new<float>(1)
var count_green = array.new<int>(1)
var movement_size_red = array.new<float>(1)
var count_red = array.new<int>(1)
var candle = array.new<int>(2, 0)
change = math.round(logReturn(source, source[1]), accuracy)
if close > open
if array.includes(movement_size_green, change)
index = array.indexof(movement_size_green, change)
array.set(count_green, index, array.get(count_green, index) + 1)
array.set(candle, 0, array.get(candle, 0) + 1)
else
array.push(movement_size_green, change)
array.push(count_green, 1)
array.set(candle, 0, array.get(candle, 0) + 1)
if close < open
if array.includes(movement_size_red, change)
index = array.indexof(movement_size_red, change)
array.set(count_red, index, array.get(count_red, index) + 1)
array.set(candle, 1, array.get(candle, 1) + 1)
else
array.push(movement_size_red, change)
array.push(count_red, 1)
array.set(candle, 1, array.get(candle, 1) + 1)
probability_green = array.new<float>(array.size(count_green))
probability_red = array.new<float>(array.size(count_red))
probability_can = array.new<float>(2)
count_green_sum = array.sum(count_green)
count_red_sum = array.sum(count_red)
count_can_sum = array.sum(candle)
for i = 0 to array.size(count_green) - 1
probability = array.get(count_green, i) / count_green_sum * 100
array.set(probability_green, i, probability)
for i = 0 to array.size(count_red) - 1
probability = array.get(count_red, i) / count_red_sum * 100
array.set(probability_red, i, probability)
for i = 0 to 1
probability = array.get(candle, i) / count_can_sum * 100
array.set(probability_can, i, probability)
[movement_size_green, movement_size_red, probability_green, probability_red, probability_can]
monte(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)=>
// Initialize the array to store the Monte Carlo simulation results
var monte_array = array.new<float>(steps)
// Loop through the number of steps
for i = 0 to steps - 1
// Generate a random number to determine if it's a green or red move
random_num_1 = math.random(0, 100, timenow)
// Check if the random number is less than or equal to the green candle probability
if random_num_1 <= array.get(probability_can, 0)
// Pick a green move size based on its probability
random_num = math.random(0, 100, timenow)
var cumulative_probability = 0.0
for j = 0 to array.size(probability_green) - 1
cumulative_probability := nz(cumulative_probability[1]) + array.get(probability_green, j)
if random_num <= cumulative_probability
// Get the corresponding green move size
move_size = array.get(movement_size_green, j)
// Add the move size to the monte_array
array.set(monte_array, i, move_size)
else
// Pick a red move size based on its probability
random_num = math.random(0, 100, timenow)
var cumulative_probability = 0.0
for j = 0 to array.size(probability_red) - 1
cumulative_probability := nz(cumulative_probability[1]) + array.get(probability_red, j)
if random_num <= cumulative_probability
// Get the corresponding red move size
move_size = array.get(movement_size_red, j)
// Add the move size to the monte_array
array.set(monte_array, i, move_size)
monte_array
sim(source, steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can) =>
var simulation = array.new<float>(steps)
movements = monte(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)
for i = 1 to steps - 1
array.set(simulation, 0, source)
array.set(simulation, i, addLogReturn(array.get(simulation, i - 1), array.get(movements, i)))
simulation
draw_lines(source, values, length, extrapolate)=>
time_quanta = -(time[1] - time)
delay = length/2 * time_quanta
size = extrapolate ? array.size(values) - 1 : length/2 - 1
array.insert(values, 0, source)
lines = array.new<line>(array.size(values) - 1)
if barstate.islast
for i = 0 to size
array.push(lines, line.new(time + time_quanta * i - delay, array.get(values, i), time + time_quanta * (i + 1) - delay, array.get(values, i + 1), xloc.bar_time, color = color.orange))
if barstate.isconfirmed
for i = 0 to array.size(lines) - 1
line.delete(array.get(lines, i))
extrapolate(source, length, accuracy) =>
ma = ta.sma(source, length)
delay = int(length/10)
[movement_size_green, movement_size_red, probability_green, probability_red, probability_can] = movement_probability(ma, accuracy)
sim = sim(ma, delay, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)
source = input.source(close, "Source")
number = input.int(20800, "Bar Start")
length = input.int(30, "Length", 20)
extrapolate = input.bool(false, "Extrapolate")
show_bar_index = input.bool(true, "Show Bar Index")
avg = ta.sma(source, length)
if bar_index > number
draw_lines(avg, extrapolate(close, length, 10), length, extrapolate)
var label barindex = na
if show_bar_index
barindex := label.new(bar_index + 1, close, text = str.tostring(bar_index), style=label.style_label_down, textcolor = close > open ? color.green : color.red, color=color.new(color.white, 100))
if barstate.isconfirmed
label.delete(barindex)
plot(avg, offset = -length/2) |
ICT Sessions | https://www.tradingview.com/script/v3VnC8yZ-ICT-Sessions/ | Remote-Trading | https://www.tradingview.com/u/Remote-Trading/ | 39 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Tatewaki97
//@version=5
indicator("ICT Sessions")
override_offset = input.bool(false, title="Override defaul offset", inline = "utc_offset")
utc_offset_input = input.int(-6, title="Offset of UTC time", minval=-12, maxval=12, inline = "utc_offset")
if not override_offset
if syminfo.type == "index" or syminfo.type == "futures"
utc_offset_input := -7
if syminfo.type == "forex" or syminfo.ticker == "DXY"
utc_offset_input := -6
plotting_offset_hours = input.int(2, title="Forward plotting hours", minval=0, maxval=12)
use_assettype_filter_inverted = input.bool(true, title="Filter Timewindows by asset type")
use_assettype_filter = not use_assettype_filter_inverted
show_weekly_separator = input.bool(true, title="Show vertical weekly separator line")
number_to_4char_string(int_number) =>
normalized_int_number = int_number
//label.new(bar_index, 1, str.format("{0, number, ###}", int_number))
if int_number <= 0
normalized_int_number := 2400 + int_number
string initial_convert = str.format("{0, number,###}", normalized_int_number)
// we cant use a for loop here because that would make the simple string a series string
if str.length(initial_convert) <= 3
initial_convert := "0" + initial_convert
if str.length(initial_convert) <= 3
initial_convert := "0" + initial_convert
if str.length(initial_convert) <= 3
initial_convert := "0" + initial_convert
initial_convert
n_bars_to_shift = math.round((plotting_offset_hours*60) / str.tonumber(timeframe.period))
// times are in UTC so one has to add 2 hours to get to german
utc_offset = (utc_offset_input - plotting_offset_hours) * 100
london_timewindow = number_to_4char_string(0900 + utc_offset) + "-" + number_to_4char_string(1701 + utc_offset)
newyork_timewindow = number_to_4char_string(1430 + utc_offset) + "-" + number_to_4char_string(2201 + utc_offset)
asian_timewindow = number_to_4char_string(0000 + utc_offset) + "-" + number_to_4char_string(1001 + utc_offset)
london_entry_kill_zone = number_to_4char_string(0800 + utc_offset) + "-" + number_to_4char_string(1101 + utc_offset)
london_entry_kill_zone_extended = number_to_4char_string(0700 + utc_offset) + "-" + number_to_4char_string(1101 + utc_offset)
london_exit_kill_zone = number_to_4char_string(1600 + utc_offset) + "-" + number_to_4char_string(1701 + utc_offset)
newyork_kill_zone = number_to_4char_string(1300 + utc_offset) + "-" + number_to_4char_string(1601 + utc_offset)
newyork_kill_zone_extended = number_to_4char_string(1200 + utc_offset) + "-" + number_to_4char_string(1601 + utc_offset)
sydney_open = number_to_4char_string(0000 + utc_offset) + "-" + number_to_4char_string(0001 + utc_offset)
london_midnight = number_to_4char_string(0100 + utc_offset) + "-" + number_to_4char_string(0101 + utc_offset)
newyork_midnight = number_to_4char_string(0600 + utc_offset) + "-" + number_to_4char_string(0601 + utc_offset)
newyork_830 = number_to_4char_string(1430 + utc_offset) + "-" + number_to_4char_string(1431 + utc_offset)
newyork_930 = number_to_4char_string(1530 + utc_offset) + "-" + number_to_4char_string(1531 + utc_offset)
london_lunch_timewindow = number_to_4char_string(1300 + utc_offset) + "-" + number_to_4char_string(1431 + utc_offset)
newyork_lunch_timewindow = number_to_4char_string(1800 + utc_offset) + "-" + number_to_4char_string(1901 + utc_offset)
newyork_lunch_until_1330 = number_to_4char_string(1900 + utc_offset) + "-" + number_to_4char_string(1931 + utc_offset)
first_30min_of_trading_window = number_to_4char_string(1530 + utc_offset) + "-" + number_to_4char_string(1601 + utc_offset)
silverbullet_am_window = number_to_4char_string(1600 + utc_offset) + "-" + number_to_4char_string(1701 + utc_offset)
silverbullet_pm_window = number_to_4char_string(2000 + utc_offset) + "-" + number_to_4char_string(2101 + utc_offset)
am850_makro = number_to_4char_string(1450 + utc_offset) + "-" + number_to_4char_string(1511 + utc_offset)
am950_makro = number_to_4char_string(1550 + utc_offset) + "-" + number_to_4char_string(1611 + utc_offset)
pre_lunch_makro = number_to_4char_string(1650 + utc_offset) + "-" + number_to_4char_string(1711 + utc_offset)
lunch_makro = number_to_4char_string(1750 + utc_offset) + "-" + number_to_4char_string(1811 + utc_offset)
last_hour = number_to_4char_string(2100 + utc_offset) + "-" + number_to_4char_string(2201 + utc_offset)
last_hour_makro = number_to_4char_string(2115 + utc_offset) + "-" + number_to_4char_string(2146 + utc_offset)
// ################################
// map the timeintervalls to values
// ---------------------------------
// sessions
float plot_london = na(time(timeframe.period, london_timewindow)) ? na : 1
float plot_newyork = na(time(timeframe.period, newyork_timewindow)) ? na : 2
float plot_asia = na(time(timeframe.period, asian_timewindow)) ? na : 0
// kill zones
float plot_london_entry_kill_zone = na(time(timeframe.period, london_entry_kill_zone)) ? na : 1.3
float plot_london_entry_kill_zone_extended = na(time(timeframe.period, london_entry_kill_zone_extended)) ? na : 1.27
float plot_london_exit_kill_zone = na(time(timeframe.period, london_exit_kill_zone)) ? na : 1.3
float plot_newyork_kill_zone = na(time(timeframe.period, newyork_kill_zone)) ? na : 2.3
float plot_newyork_kill_zone_extended = na(time(timeframe.period, newyork_kill_zone_extended)) ? na : 2.27
// reference points -- 9:30 + midnights
float scatter_sydney = na(time(timeframe.period, sydney_open)) ? na : 0
float scatter_london_midnight = na(time(timeframe.period, london_midnight)) ? na : 1
float scatter_newyork_midnight = na(time(timeframe.period, newyork_midnight)) ? na : 2
float scattter_newyork_830 = na(time(timeframe.period, newyork_830)) ? na : 2.3
float scattter_newyork_930 = na(time(timeframe.period, newyork_930)) ? na : 2.3
// lunch breaks
float plot_london_lunch = na(time(timeframe.period, london_lunch_timewindow)) ? na : 1.15
float plot_newyork_lunch_until_1330= na(time(timeframe.period, newyork_lunch_until_1330)) ? na : 2.15
float plot_newyork_lunch = na(time(timeframe.period, newyork_lunch_timewindow)) ? na : 2.15
float plot_first_30min_of_trading_window = na(time(timeframe.period, first_30min_of_trading_window)) ? na : 2.15
float plot_silverbullet_am_window = na(time(timeframe.period, silverbullet_am_window)) ? na : 2.15
float plot_silverbullet_pm_window = na(time(timeframe.period, silverbullet_pm_window)) ? na : 2.15
float plot_am850_makro = na(time(timeframe.period, am850_makro)) ? na : 2.6
float plot_am950_makro = na(time(timeframe.period, am950_makro)) ? na : 2.6
float plot_pre_lunch_makro = na(time(timeframe.period, pre_lunch_makro)) ? na : 2.6
float plot_lunch_makro = na(time(timeframe.period, lunch_makro)) ? na : 2.6
float plot_last_hour = na(time(timeframe.period, last_hour)) ? na : 2.6
float plot_last_hour_makro = na(time(timeframe.period, last_hour_makro)) ? na : 2.6
// ################################
// start painting the plots
// ---------------------------------
// weekly separator
offset_in_ms = utc_offset_input * 60 * 60 * 1000
if show_weekly_separator and weekofyear(time-offset_in_ms) != weekofyear(time-1-offset_in_ms)
line.new(bar_index, 3, bar_index, -1, color=color.black, width=2, style=line.style_dashed)
// futures & indices -- full sessions
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_london : na, title="London Session" ,style=plot.style_linebr, color=color.blue, linewidth=3, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_newyork : na, title="New York Session", style=plot.style_linebr, color=#557588, linewidth=3, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_asia : na, title="Asia Session", style=plot.style_linebr, color=color.orange, linewidth=3, offset=n_bars_to_shift)
// forex -- killzones
plot(plot_london_entry_kill_zone, title="London killzone" ,style=plot.style_linebr, color=color.aqua, linewidth=4, offset=n_bars_to_shift)
plot(plot_london_entry_kill_zone_extended, title="London killzone ext" ,style=plot.style_linebr, color=color.aqua, linewidth=2, offset=n_bars_to_shift)
plot((syminfo.type == "forex" or use_assettype_filter) ? plot_london_exit_kill_zone : na, title="London Exitzone" ,style=plot.style_linebr, color=color.maroon, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "forex" or use_assettype_filter) ? plot_newyork_kill_zone : na, title="New York killzone" ,style=plot.style_linebr, color=color.teal, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "forex" or use_assettype_filter) ? plot_newyork_kill_zone_extended : na, title="New York killzone ext" ,style=plot.style_linebr, color=color.teal, linewidth=2, offset=n_bars_to_shift)
// reference points -- 9:30 + midnights
//plot(scatter_sydney, title="Sydney midnight", style=plot.style_circles, color=color.black, linewidth=3, offset=n_bars_to_shift)
plot(scatter_london_midnight, title="London midnight", style=plot.style_cross, color=color.black, linewidth=2, offset=n_bars_to_shift)
plot(scatter_newyork_midnight, title="New York midnight", style=plot.style_cross, color=color.black, linewidth=2, offset=n_bars_to_shift)
// lunch breaks
plot(plot_london_lunch, title="London Lunch" ,style=plot.style_linebr, color=color.red, linewidth=6, offset=n_bars_to_shift)
plot(plot_newyork_lunch, title="New York Lunch" ,style=plot.style_linebr, color=#d42626, linewidth=6, offset=n_bars_to_shift)
plot(plot_newyork_lunch_until_1330, title="New York Lunch 13" ,style=plot.style_linebr, color=color.red, linewidth=6, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_first_30min_of_trading_window : na, title="First 30min of trading", style=plot.style_linebr, color=#ff9400, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_silverbullet_am_window : na, title="Silberbullet AM", style=plot.style_linebr, color=#4c6a77, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_silverbullet_pm_window : na, title="Silberbullet PM", style=plot.style_linebr, color=#4c6a77, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_am850_makro : na, title="8:50 makro", style=plot.style_linebr, color=#1b5e20, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_am950_makro : na, title="9:50 makro", style=plot.style_linebr, color=#1b5e20, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_pre_lunch_makro : na, title="Pre NY Lunch makro", style=plot.style_linebr, color=#1b5e20, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_lunch_makro : na, title="NY Lunch makro", style=plot.style_linebr, color=#490000, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_last_hour : na, title="Last NY hour of trading", style=plot.style_linebr, color=#16d323, linewidth=4, offset=n_bars_to_shift)
plot((syminfo.type == "index" or syminfo.type == "futures" or use_assettype_filter) ? plot_last_hour_makro : na, title="Last NY hour of trading makro", style=plot.style_linebr, color=#1b5e20, linewidth=4, offset=n_bars_to_shift)
plot(scattter_newyork_830, title="New York 8:30", style=plot.style_cross, color=color.black, linewidth=3, offset=n_bars_to_shift)
plot(scattter_newyork_930, title="New York 9:30", style=plot.style_circles, color=color.black, linewidth=3, offset=n_bars_to_shift)
// vertical delimiters
plot(3, title="Upper line", style=plot.style_line, color=color.silver, linewidth=1, offset=n_bars_to_shift)
plot(-1, title="Lower line", style=plot.style_line, color=color.silver, linewidth=1, offset=n_bars_to_shift)
|
[TT] Sectors Dist % From MA | https://www.tradingview.com/script/zmrAwEtb-TT-Sectors-Dist-From-MA/ | tradersTerminal | https://www.tradingview.com/u/tradersTerminal/ | 8 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © tradersTerminal
//@version=5
//study("Percentage Distance From Moving Average")
indicator("[TT] Sectors Dist % From MA")
MA_Period = input(200)
//list of all sectors
sector1 = input("XLC")
sector2 = input("XLY")
sector3 = input("XLP")
sector4 = input("XLE")
sector5 = input("XLF")
sector6 = input("XLV")
sector7 = input("XLI")
sector8 = input("XLB")
sector9 = input("XLRE")
sector10 = input("XLK")
sector11 = input("XLU")
color1 =input(color.new(color.purple, 0))
color2 =input(color.new(#9cbd51, 0))
color3 =input(color.new(#51a4bd, 0))
color4 =input(color.new(#cc904b, 0))
color5 =input(color.new(#34a039, 0))
color6 =input(color.new(#2f498f, 0))
color7 =input(color.new(#af45aa, 0))
color8 =input(color.new(#868686, 0))
color9 =input(color.new(#ff3e3e, 0))
color10 =input(color.new(#faf740, 0))
color11 =input(color.new(#ffffff, 0))
//get last close and MA
price1 = request.security(sector1,timeframe.period, close)
ma1 = ta.sma(price1,MA_Period)
PercentageDifference1 = (price1 - ma1) / ma1 * 100
plot(PercentageDifference1,"1",color1)
price2 = request.security(sector2,timeframe.period, close)
ma2 = ta.sma(price2,MA_Period)
PercentageDifference2 = (price2 - ma2) / ma2 * 100
plot(PercentageDifference2,"2",color2)
price3 = request.security(sector3,timeframe.period, close)
ma3 = ta.sma(price3,MA_Period)
PercentageDifference3 = (price3 - ma3) / ma3 * 100
plot(PercentageDifference3,"3",color3)
price4 = request.security(sector4,timeframe.period, close)
ma4 = ta.sma(price4,MA_Period)
PercentageDifference4 = (price4 - ma4) / ma4 * 100
plot(PercentageDifference4,"4",color4)
price5 = request.security(sector5,timeframe.period, close)
ma5 = ta.sma(price5,MA_Period)
PercentageDifference5 = (price5 - ma5) / ma5 * 100
plot(PercentageDifference5,"5",color5)
price6 = request.security(sector6,timeframe.period, close)
ma6 = ta.sma(price6,MA_Period)
PercentageDifference6 = (price6 - ma6) / ma6 * 100
plot(PercentageDifference6,"6",color6)
price7 = request.security(sector7,timeframe.period, close)
ma7 = ta.sma(price7,MA_Period)
PercentageDifference7 = (price7 - ma7) / ma7 * 100
plot(PercentageDifference7,"7",color7)
price8 = request.security(sector8,timeframe.period, close)
ma8 = ta.sma(price8,MA_Period)
PercentageDifference8 = (price8 - ma8) / ma8 * 100
plot(PercentageDifference8,"8",color8)
price9 = request.security(sector9,timeframe.period, close)
ma9 = ta.sma(price9,MA_Period)
PercentageDifference9 = (price9 - ma9) / ma9 * 100
plot(PercentageDifference9,"9",color9)
price10 = request.security(sector10,timeframe.period, close)
ma10 = ta.sma(price10,MA_Period)
PercentageDifference10 = (price10 - ma10) / ma10 * 100
plot(PercentageDifference10,"10",color10)
price11 = request.security(sector11,timeframe.period, close)
ma11 = ta.sma(price11,MA_Period)
PercentageDifference11 = (price11 - ma11) / ma11 * 110
plot(PercentageDifference11,"11",color11) |
Volatility patterns / quantifytools | https://www.tradingview.com/script/HjIKKzVd-Volatility-patterns-quantifytools/ | quantifytools | https://www.tradingview.com/u/quantifytools/ | 339 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © quantifytools
//@version=5
indicator("Volatility patterns", overlay=true, max_boxes_count = 500, max_lines_count = 500)
// Inputs
//Range inputs
groupRangeSettings = "Range pattern settings"
i_minInfluence = input.int(6, "Influence time", group = groupRangeSettings)
i_compressRequirement = input.int(4, "Min. compressed pivots", group = groupRangeSettings)
i_compressPiv = input.int(2, "Pivot length", group = groupRangeSettings)
//Bar inputs
groupBarSettings = "Candle pattern settings"
i_minInfluenceIndBar = input.int(6, "Influence time", group = groupBarSettings)
i_indBarSensitivity = input.int(2, "Indecision candle sensitivity", group = groupBarSettings, minval=1, maxval=3)
//Visual inputs
groupVisual= "Visuals"
indBarPatternCol = input.color(color.yellow, "Candle", group=groupVisual, inline="Pattern")
indBarPatternColoring = input.color(color.rgb(255, 235, 59, 46), "Influence", group=groupVisual, inline="Pattern")
rangePatternCol = input.color(color.orange, "Range", group=groupVisual, inline="Pattern2")
rangePatternColoring = input.color(color.rgb(255, 170, 59, 53), "Influence", group=groupVisual, inline="Pattern2")
i_indBarSize = input.int(5, "Candle width", group = groupVisual)
//Table inputs
groupTable = "Table"
tablePos = input.string("Top right", "Table position", options=["Top right", "Bottom right", "Bottom left", "Top left"], group=groupTable)
tableSize = input.int(2, "Table size", maxval=5, minval=1, group=groupTable)
// Initializing counters
//Tracking highs/lows
var float prevHigh = 0
var float prevLow = 0
//Reset candle index for volatility coloring
var int resetIndexRange = 0
var int resetIndexIndBar = 0
//Compressed turns counters
var int compressCount = 0
var int compressCount2 = 0
//Volatility metric counters
var float indBarPeriods = 0
var float rangePeriods = 0
var float indBarPeakVol = 0
var float rangePeakVol = 0
var float indBarCumVol = 0
var float rangeCumVol = 0
var float indBarCumInfluence = 0
var float rangeCumInfluence = 0
// Candle patterns
//Defining relative close
rangePos = (close - low) / (high - low)
//Defining volatility and volatility MA
volatility = high - low
smaVolatility = ta.sma(volatility, 20)
//Volatility multiplier (volatility relative to volatility SMA 20)
volatilityMultiplier = (volatility / smaVolatility)
//Balanced engulfing highs & lows
lowSpread = (low[1] - low)
highSpread = (high - high[1])
balancedHl = (highSpread <= lowSpread * 1.1) and (lowSpread <= highSpread * 1.1)
//Volatility regime
volatilityRegime = ta.sma(volatilityMultiplier, 10)
//indBar candle types
inBar = high < high[1] and low > low[1]
indecisionEngulf = volatilityMultiplier <= 0.70 and rangePos >= 0.40 and rangePos <= 0.60 and balancedHl
lowVolHighVol = volatilityRegime < 0.70 and volatilityMultiplier >= 1.5
//Grouping indBar candle types
anyIndBar = (inBar or indecisionEngulf or lowVolHighVol) and barstate.isconfirmed
//Defining indBar Pattern
indBarPattern = i_indBarSensitivity == 1 ? anyIndBar : i_indBarSensitivity == 2 ? anyIndBar and (anyIndBar[1] or anyIndBar[2]) : anyIndBar and anyIndBar[1]
//Set reset candle index for indBar
if indBarPattern
resetIndexIndBar := bar_index + i_minInfluenceIndBar
//Volatility coloring for indBar
indBarColoring = bar_index <= resetIndexIndBar
// Compressed range #1 (higher lows, lower highs)
//Defining pivots
pivLegs = i_compressPiv
pivHigh = ta.pivothigh(high, pivLegs, pivLegs)
pivLow = ta.pivotlow(low, pivLegs, pivLegs)
//Populating trackers
if pivLow
prevLow := low[pivLegs]
if pivHigh
prevHigh := high[pivLegs]
//Valid compression scenarios
lhPivot = prevHigh < prevHigh[1] and pivHigh
hlPivot = prevLow > prevLow[1] and pivLow
//Populating compress counter
if lhPivot or hlPivot
compressCount += 1
//Reseting compression counter on failed reaction
if high > prevHigh or low < prevLow
compressCount := 0
//Defining compressed range
rangePattern = compressCount == i_compressRequirement and barstate.isconfirmed
//Set bar index for volatility color reset
if rangePattern
resetIndexRange := bar_index + i_minInfluence
//Reset counters when bar index is met
if bar_index == resetIndexRange
resetIndexRange := 0
compressCount := 0
// Compressed range #2 (low volatility pivots)
//Calculating bench mark for measuring how close a pivot is to an average pivot. Exclude pre and post market due to inherent low volatility.
pivChange = (pivHigh or pivLow) and session.ispremarket == false and session.ispostmarket == false ? ( (prevHigh / prevLow) - 1) * 100 : na
pivChangeSma = ta.sma(pivChange, 20)
pivChangeMultiplier = pivChange / pivChangeSma
//Populating counters
if (pivHigh or pivLow) and pivChangeMultiplier <= 0.50
compressCount2 += 1
if (pivHigh or pivLow) and pivChangeMultiplier >= 0.50
compressCount2 := 0
//Defining compressed range scenario #2
rangePattern2 = compressCount2 == i_compressRequirement and barstate.isconfirmed
//Set reset candle index for compressed range #2
if rangePattern2
resetIndexRange := bar_index + i_minInfluence
//Volatility influence time
rangeColoring = bar_index <= resetIndexRange
// Metrics
//Bars since influence period false
barssinceInbInfluenceFalse = ta.barssince(indBarColoring == false)
//Bars since influence period false
barssinceRangeInfluenceFalse = ta.barssince(rangeColoring == false)
//Populating cumulative counters
if rangeColoring and na(volatilityMultiplier) == false
rangeCumVol += volatilityMultiplier
rangeCumInfluence += 1
if indBarColoring and na(volatilityMultiplier) == false
indBarCumVol += volatilityMultiplier
indBarCumInfluence += 1
//Peak relative volatility
peakRangeVol = barssinceRangeInfluenceFalse > 0 ? ta.highest(volatilityMultiplier, barssinceRangeInfluenceFalse) : na
peakIndBarVol = barssinceInbInfluenceFalse > 0 ? ta.highest(volatilityMultiplier, barssinceInbInfluenceFalse) : na
//When indecision bar volatility influence time is over, populate peak volatility and indecision bar counters
if indBarColoring[1] and indBarColoring == false and na(volatilityMultiplier) == false
indBarPeakVol += peakIndBarVol[1]
indBarPeriods += 1
//When range volatility influence time is over, populate peak volatility and range pattern counters
if rangeColoring[1] and rangeColoring == false and na(volatilityMultiplier) == false
rangePeakVol += peakRangeVol[1]
rangePeriods += 1
//Avg peak volatility
avgIndBarPeak = math.round(indBarPeakVol / indBarPeriods, 2)
avgRangePeak = math.round(rangePeakVol / rangePeriods, 2)
avgIndBarVol = math.round(indBarCumVol / indBarCumInfluence, 2)
avgRangeVol = math.round(rangeCumVol / rangeCumInfluence, 2)
// Table
//Table position and size
tablePosition = tablePos == "Top right" ? position.top_right : tablePos == "Bottom right" ? position.bottom_right : tablePos == "Bottom left" ? position.bottom_left : position.top_left
tableTextSize = tableSize == 1 ? size.tiny : tableSize == 2 ? size.small : tableSize == 3 ? size.normal : tableSize == 4 ? size.huge : size.large
//Initializing table
var metricTable = table.new(position = tablePosition, columns = 50, rows = 50, bgcolor = color.new(color.black, 80), border_width = 3, border_color=color.rgb(23, 23, 23))
//Divider symbol
div = "｜"
//Populating table
table.cell(table_id = metricTable, column = 0, row = 0, text = "Candle patterns: " + str.tostring(indBarPeriods), text_color=color.yellow, text_halign = text.align_center, text_size=tableTextSize)
table.cell(table_id = metricTable, column = 0, row = 1, text = "Range patterns: " + str.tostring(rangePeriods), text_color=color.orange, text_halign = text.align_center, text_size=tableTextSize)
table.cell(table_id = metricTable, column = 1, row = 0, text = " Avg. volatility: " + str.tostring(avgIndBarVol) + "x" + div + "Avg. peak: " + str.tostring(avgIndBarPeak) + "x", text_color=color.white, text_halign = text.align_left, text_size=tableTextSize)
table.cell(table_id = metricTable, column = 1, row = 1, text = " Avg. volatility: " + str.tostring(avgRangeVol) + "x" + div + "Avg. peak: " + str.tostring(avgRangePeak) + "x", text_color=color.white, text_halign = text.align_left, text_size=tableTextSize)
// Alerts
//Candle pattern
alertcondition(indBarPattern, "Indecision candle pattern", "Indecision candle pattern detected.")
//Range pattern
alertcondition(rangePattern or rangePattern2, "Range pattern", "Range pattern detected.")
//Grouped
alertcondition(indBarPattern or rangePattern or rangePattern2, "Volatility pattern (any)", "Volatility pattern detected.")
// Plots
//Piv legs lookback
pivlb = pivLegs * 2
//Highest high/lowest low for compressed range highlight
highestRange = ta.highest(high, pivlb * i_compressRequirement)
lowestRange = ta.lowest(low, pivlb * i_compressRequirement)
//If range Pattern condition is met, draw box
if rangePattern2 and rangePattern2[1] == false
box.new(left=bar_index - (pivlb * i_compressRequirement), top=highestRange, right=bar_index, bottom=lowestRange, bgcolor=color.new(color.yellow, 100), border_color=rangePatternCol, border_width=1, border_style = line.style_dotted, text="", text_color=color.white, text_valign = text.align_bottom)
//If range Pattern condition is met, draw box
if rangePattern and rangePattern[1] == false
box.new(left=bar_index - (pivlb * i_compressRequirement), top=highestRange, right=bar_index, bottom=lowestRange, bgcolor=color.new(color.yellow, 100), border_color=rangePatternCol, border_width=1, border_style = line.style_dotted, text="", text_color=color.white, text_valign = text.align_bottom)
//If indBar Pattern condition is met, draw line
if indBarPattern
line.new(bar_index[0], high[0], bar_index[0], low[0], xloc=xloc.bar_index, color=indBarPatternCol, width=i_indBarSize)
//Volatility color
compressColBorder = rangeColoring ? rangePatternColoring : indBarColoring ? indBarPatternColoring : color.new(color.gray, 100)
//Coloring border only
plotcandle(open, high, low, close, title="Volatility color", color=color.new(color.gray, 100), wickcolor=color.new(color.gray, 100), bordercolor=compressColBorder)
//Plotting calculations
plot( volatilityMultiplier , "Relative volatility (volatility/volatility SMA 20)", display=display.data_window, color=color.white)
plot(0, "==========[ Peak counters ]", display=display.data_window)
plot( rangePeriods , "Compressed range influence periods", display=display.data_window, color=color.orange)
plot( rangePeakVol , "Cumulative peak volatility", display=display.data_window, color=color.orange)
plot( avgRangePeak , "Average peak volatility", display=display.data_window, color=color.orange)
plot( rangeColoring[1] and rangeColoring == false ? rangePeakVol - rangePeakVol[1] : na, "Recent peak volatility", display=display.data_window, color=color.rgb(237, 163, 51))
plot( indBarPeriods , "Indecision bar influence periods", display=display.data_window, color=color.yellow)
plot( indBarPeakVol , "Cumulative peak volatility", display=display.data_window, color=color.yellow)
plot( avgIndBarPeak , "Average peak volatility", display=display.data_window, color=color.yellow)
plot( indBarColoring[1] and indBarColoring == false ? indBarPeakVol - indBarPeakVol[1] : na, "Recent peak volatility", display=display.data_window, color=color.rgb(246, 238, 167))
plot(0, "==========[ Average counters ]", display=display.data_window)
plot( rangeCumInfluence , "Cumulative influence bars", display=display.data_window, color=color.orange)
plot( rangeCumVol , "Cumulative influence bar volatility", display=display.data_window, color=color.orange)
plot( avgRangeVol , "Average range pattern volatility", display=display.data_window, color=color.orange)
plot( indBarCumInfluence , "Cumulative influence bars", display=display.data_window, color=color.yellow)
plot( indBarCumVol , "Cumulative influence bar volatility", display=display.data_window, color=color.yellow)
plot( avgIndBarVol , "Average indecision bar pattern volatility", display=display.data_window, color=color.yellow)
|
Deming Linear Regression [wbburgin] | https://www.tradingview.com/script/bp4TcdDe-Deming-Linear-Regression-wbburgin/ | wbburgin | https://www.tradingview.com/u/wbburgin/ | 78 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © wbburgin
//
//@version=5
indicator("Deming Linear Regression [wbburgin]", overlay=true)
//Deming regression is a type of linear regression used to model the relationship between two variables when there is
//variability in both variables. Deming regression provides a solution by simultaneously
//accounting for the variability in both the independent and dependent variables, resulting in a more accurate
//estimation of the underlying relationship. In the hard-science fields, where measurements are critically important
//to judging the conclusions drawn from data, Deming regression can be used to account for measurement error.
//Tradingview's default ta.linreg() function uses least squares linear regression, which is similar but different than
//Deming regression. In least squares regression, the regression function minimizes the sum of the squared vertical
//distances between the data points and the fitted line. This method assumes that the errors or variability are only
//present in the y-values (dependent variable), and that the x-values (independent variable) are measured without error.
//In time series data used in trading, Deming regression can be more accurate than least squares regression because the
//ratio of the variances of the x and y variables is large. X is the bar index, which is an incrementally-increasing
//function that has little variance, while Y is the price data, which has extremely high variance when compared to the
//bar index. In such situations, least squares regression can be heavily influenced by outliers or extreme points in the
//data, whereas Deming regression is more resistant to such influence.
//Additionally, if your x-axis uses variable widths - such as renko blocks or other types of non-linear widths - Deming
//regression might be more effective than least-squares linear regression because it accounts for the variability in
//your x-values as well.
//In contrast to least squares regression, Deming regression takes into account the variability or errors in both the
//x- and y-values. It minimizes the sum of the squared perpendicular distances between the data points and the fitted
//line, taking into account both the x- and y-variability. This makes Deming regression more robust in both variables
//than least squares regression.
length = input.int(50,"Length")
compareToPine = input.bool(false,"Compare to Normal Least Squares Linreg")
y = array.new_float()
for i = 0 to length -1
close_i = close[length - 1 - i]
array.push(y,close_i)
x = array.new_float()
for i = 0 to length -1
barindex_i = bar_index[length - 1 - i]
array.push(x,barindex_i)
x_mean = array.avg(x)
y_mean = array.avg(y)
x_stdev = array.stdev(x)
y_stdev = array.stdev(y)
cov = 0.0
count = 0
for i = 0 to length - 1
if not na(array.get(x,i)) and not na(array.get(y,i))
cov += (array.get(x,i) - x_mean) * (array.get(y,i) - y_mean)
count += 1
if count > 1
cov := cov / (count - 1)
slope = (y_stdev / x_stdev) * (cov / (math.pow(x_stdev,2) + math.pow(y_stdev,2)))
intercept = y_mean - slope * x_mean
demingreg = slope * array.get(x,0) + intercept
pine_linreg = ta.linreg(close,length,0)
plot(demingreg, "Deming Linear Regression", color=color.white)
plot(not compareToPine ? na: pine_linreg,"Least Squares Regression",color=color.yellow) |
RGB Color Codes Chart | https://www.tradingview.com/script/GjhWmxLy-RGB-Color-Codes-Chart/ | RozaniGhani-RG | https://www.tradingview.com/u/RozaniGhani-RG/ | 41 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RozaniGhani-RG
//@version=5
indicator('RGB Color Codes Chart', 'RCCC', true)
// 0. Inputs
// 1. Types
// 2. Custom Functions
// 3. Arrays and Variables
// 4. Constructs
//#region ———————————————————— 0. Inputs
Tooltip0 = 'Small font size recommended for mobile app or multiple layout'
Title0 = 'Show One color only instead Gradient Color'
Title1 = 'Value Reference'
titleRed = input.bool( true, 'Red', group = 'Color', inline = '0')
titleOrange = input.bool( true, 'Orange', group = 'Color', inline = '0')
titleYellow = input.bool( true, 'Yellow', group = 'Color', inline = '0')
titleLime = input.bool( true, 'Lime', group = 'Color', inline = '0')
titleGreen = input.bool( true, 'Green', group = 'Color', inline = '1')
titleTeal = input.bool( true, 'Teal', group = 'Color', inline = '1')
titleAqua = input.bool( true, 'Aqua', group = 'Color', inline = '1')
titleBlue = input.bool( true, 'Blue', group = 'Color', inline = '1')
titleNavy = input.bool( true, 'Navy', group = 'Color', inline = '2')
titlePurple = input.bool( true, 'Purple', group = 'Color', inline = '2')
titleMaroon = input.bool( true, 'Maroon', group = 'Color', inline = '2')
titleFuchsia = input.bool( true, 'Fuchsia', group = 'Color', inline = '3')
titleGray = input.bool( true, 'Gray', group = 'Color', inline = '3')
showTitle = input.bool( true, 'Show Title', group = 'Others')
showString = input.string( 'RGB', 'Select Values', group = 'Others', options = ['Full', 'HEX', 'RGB', 'R', 'G', 'B', 'na'])
fontSize = input.string('small', 'Font Size', group = 'Others', options = ['tiny', 'small', 'normal', 'large', 'huge'], tooltip = Tooltip0)
showGradient = input.bool( false, Title0, group = 'Others')
intGradient = input.int( 8, Title1, minval = 0, maxval = 8)
//#endregion
//#region ———————————————————— 1. Types
// @type Used for int
// @field r Int value for red
// @field g Int value for green
// @field b Int value for blue
type rgb
int r = na
int g = na
int b = na
// @type Used for string
// @field quotient String value for quotient
// @field remainder String value for remainder
type pair
string quotient = na
string remainder = na
// @type Used for cell properties
// @field title String value for title
// @field color Color value for col
type properties
bool enable = na
string title = na
color col = na
//#endregion
//#region ———————————————————— 2. Custom Functions
// @function createQuotient
// @param val
// @returns hex
switchHex(int val = na) =>
hex = switch val
10 => 'A'
11 => 'B'
12 => 'C'
13 => 'D'
14 => 'E'
15 => 'F'
=> str.tostring(val)
// @function createQuotient
// @param dividend
// @returns quotient
createQuotient( int dividend = na) => int(dividend / 16)
// @function createRemainder
// @param dividend
// @returns remainder
createRemainder(int dividend = na) => int(dividend % 16)
// @function doubleHex
// @param dividend
// @returns double
doubleHex(int dividend = na) =>
quotient = switchHex(createQuotient( dividend))
remainder = switchHex(createRemainder(dividend))
double = pair.new(quotient, remainder)
double
// @function convertRGBtoHex
// @param RGB
// @returns hex
convertRGBtoHex(rgb RGB = na) =>
hexR = doubleHex(RGB.r)
hexG = doubleHex(RGB.g)
hexB = doubleHex(RGB.b)
hex = '#' + hexR.quotient + hexR.remainder + hexG.quotient + hexG.remainder + hexB.quotient + hexB.remainder
hex
// @function groupRGB
// @param i0, i1, i2
// @returns id
method groupRGB(array<int> i0 = na, array<int> i1 = na, array<int> i2 = na) =>
id = array.new<rgb>(9)
for i = 0 to 8
id.set(i, rgb.new(i0.get(i), i1.get(i), i2.get(i)))
id
// @function stringRGB
// @param RGB
// @returns id
method stringRGB(array<rgb> RGB = na) =>
id = array.new<string>(9)
for i = 0 to 8
id.set(i, 'HEX : ' + convertRGBtoHex(RGB.get(i)) + '\nR : ' + str.tostring(RGB.get(i).r, '000') + '\nG : ' + str.tostring(RGB.get(i).g, '000') + '\nB : ' + str.tostring(RGB.get(i).b, '000'))
id
// @function createRGB
// @param id, index
// @returns model
method createRGB(array<rgb> id = na, int index = na)=>
r = id.get(index).r
g = id.get(index).g
b = id.get(index).b
model = color.rgb(r, g, b)
model
// @function createColor
// @param id
// @returns col
method createColor(array<rgb> id = na) =>
col = array.new<color>(9)
for i = 0 to 8
col.set(i, id.createRGB(i))
col
// @function createCell
// @param id, column, i, str, bg, fg
// @returns id.cell
method createCell( table id = na, int column = na, int i = na,
string[] str = na, color[] bg = na, color[] fg = na) =>
id.cell(column, i + 1, '',
bgcolor = bg.get(i),
text_size = fontSize,
text_color = fg.get(i),
tooltip = array.get(str, i))
// @function boolCell
// @param show, id, column, i, str, bg, fg
// @returns id.cell
method boolCell( array<properties> show = na, table id = na, int column = na,
int i = na, string[] str = na, color[] bg = na, color[] fg = na) =>
if show.get(column).enable
id.createCell(column, i, str, bg, fg)
// @function boolCell
// @param show, id, column, i, str, bg, fg
// @returns id.cell
method setCellText(array<properties> show = na, table id = na, int column = na, int i = na, string[] str = na, array<rgb> RGB = na) =>
disp = switch showString
'Full' => array.get(str, i)
'HEX' => 'HEX : ' + convertRGBtoHex(RGB.get(i))
'RGB' => 'R : ' + str.tostring(RGB.get(i).r, '000') + '\nG : ' + str.tostring(RGB.get(i).g, '000') + '\nB : ' + str.tostring(RGB.get(i).b, '000')
'R' => 'R : ' + str.tostring(RGB.get(i).r, '000')
'G' => 'G : ' + str.tostring(RGB.get(i).g, '000')
'B' => 'B : ' + str.tostring(RGB.get(i).b, '000')
'na' => ' '
if show.get(column).enable
id.cell_set_text(column, i + 1, disp)
//#endregion
//#region ———————————————————— 3. Arrays and Variables
colorText = array.new<color>(9)
palette = array.new<properties>(13)
var tbl = table.new(position.middle_center, 13, 10, border_width = 1)
for i = 0 to 3
colorText.set(i, color.white)
for i = 4 to 8
colorText.set(i, color.black)
// 0 1 2 3 4 5 6 7 8
redR = array.from( 51, 102, 153, 204, 255, 255, 255, 255, 255)
redG = array.from( 0, 0, 0, 0, 0, 51, 102, 153, 204)
orangeG = array.from( 25, 51, 76, 102, 128, 153, 178, 204, 229)
tealB = array.from( 25, 51, 76, 102, 128, 153, 178, 153, 229)
blueG = array.from( 25, 51, 76, 102, 128, 153, 178, 204, 229)
purpleG = array.from( 25, 51, 76, 102, 127, 153, 178, 204, 229)
grayR = array.from( 0, 32, 64, 96, 128, 160, 192, 224, 225)
redRGB = redR.groupRGB( redG, redG), strRed = stringRGB( redRGB), colorRed = redRGB.createColor()
orangeRGB = redR.groupRGB(orangeG, redG), strOrange = stringRGB( orangeRGB), colorOrange = orangeRGB.createColor()
yellowRGB = redR.groupRGB( redR, redG), strYellow = stringRGB( yellowRGB), colorYellow = yellowRGB.createColor()
limeRGB = orangeG.groupRGB( redR, redG), strLime = stringRGB( limeRGB), colorLime = limeRGB.createColor()
greenRGB = redG.groupRGB( redR, redG), strGreen = stringRGB( greenRGB), colorGreen = greenRGB.createColor()
tealRGB = redG.groupRGB( redR, orangeG), strTeal = stringRGB( tealRGB), colorTeal = tealRGB.createColor()
aquaRGB = redG.groupRGB( redR, redR), strAqua = stringRGB( aquaRGB), colorAqua = aquaRGB.createColor()
blueRGB = redG.groupRGB( blueG, redR), strBlue = stringRGB( blueRGB), colorBlue = blueRGB.createColor()
navyRGB = redG.groupRGB( redG, redR), strNavy = stringRGB( navyRGB), colorNavy = navyRGB.createColor()
purpleRGB = purpleG.groupRGB( redG, redR), strPurple = stringRGB( purpleRGB), colorPurple = purpleRGB.createColor()
fuchsiaRGB = redR.groupRGB( redG, purpleG), strFuchsia = stringRGB(fuchsiaRGB), colorFuchsia = fuchsiaRGB.createColor()
maroonRGB = redR.groupRGB( redG, redR), strMaroon = stringRGB( maroonRGB), colorMaroon = maroonRGB.createColor()
grayRGB = grayR.groupRGB( grayR, grayR), strGray = stringRGB( grayRGB), colorGray = grayRGB.createColor()
palette.set( 0, properties.new(titleRed, 'Red', color.red))
palette.set( 1, properties.new(titleOrange, 'Orange', color.orange))
palette.set( 2, properties.new(titleYellow, 'Yellow', color.yellow))
palette.set( 3, properties.new(titleLime, 'Lime', color.lime))
palette.set( 4, properties.new(titleGreen, 'Green', color.green))
palette.set( 5, properties.new(titleTeal, 'Teal', color.teal))
palette.set( 6, properties.new(titleAqua, 'Aqua', color.aqua))
palette.set( 7, properties.new(titleBlue, 'Blue', color.blue))
palette.set( 8, properties.new(titleNavy, 'Navy', color.navy))
palette.set( 9, properties.new(titlePurple, 'Purple', color.purple))
palette.set(10, properties.new(titleFuchsia, 'Fuchsia', color.fuchsia))
palette.set(11, properties.new(titleMaroon, 'Maroon', color.maroon))
palette.set(12, properties.new(titleGray, 'Gray', color.gray))
[i0, i1] = switch showGradient
true => [intGradient, intGradient]
false => [ 0, 8]
//#endregion
//#region ———————————————————— 4. Constructs
if barstate.islast
for i = i0 to i1
palette.boolCell(tbl, 0, i, strRed, colorRed, colorText)
palette.boolCell(tbl, 1, i, strOrange, colorOrange, colorText)
palette.boolCell(tbl, 2, i, strYellow, colorYellow, colorText)
palette.boolCell(tbl, 3, i, strLime, colorLime, colorText)
palette.boolCell(tbl, 4, i, strGreen, colorGreen, colorText)
palette.boolCell(tbl, 5, i, strTeal, colorTeal, colorText)
palette.boolCell(tbl, 6, i, strAqua, colorAqua, colorText)
palette.boolCell(tbl, 7, i, strBlue, colorBlue, colorText)
palette.boolCell(tbl, 8, i, strNavy, colorNavy, colorText)
palette.boolCell(tbl, 9, i, strPurple, colorPurple, colorText)
palette.boolCell(tbl,10, i, strMaroon, colorMaroon, colorText)
palette.boolCell(tbl,11, i, strFuchsia, colorFuchsia, colorText)
palette.boolCell(tbl,12, i, strGray, colorGray, colorText)
for i = i0 to i1
palette.setCellText(tbl, 0, i, strRed, redRGB)
palette.setCellText(tbl, 1, i, strOrange, orangeRGB)
palette.setCellText(tbl, 2, i, strYellow, yellowRGB)
palette.setCellText(tbl, 3, i, strLime, limeRGB)
palette.setCellText(tbl, 4, i, strGreen, greenRGB)
palette.setCellText(tbl, 5, i, strTeal, tealRGB)
palette.setCellText(tbl, 6, i, strAqua, aquaRGB)
palette.setCellText(tbl, 7, i, strBlue, blueRGB)
palette.setCellText(tbl, 8, i, strNavy, navyRGB)
palette.setCellText(tbl, 9, i, strPurple, purpleRGB)
palette.setCellText(tbl,10, i, strMaroon, maroonRGB)
palette.setCellText(tbl,11, i, strFuchsia, fuchsiaRGB)
palette.setCellText(tbl,12, i, strGray, grayRGB)
for i = 0 to 12
if showTitle and palette.get(i).enable
tbl.cell(i, 0, palette.get(i).title, bgcolor = palette.get(i).col, text_size = fontSize, text_color = color.white)
//#endregion |
Line Colorizer - Durbtrade | https://www.tradingview.com/script/aTZiV0V7-Line-Colorizer-Durbtrade/ | Durbtrade | https://www.tradingview.com/u/Durbtrade/ | 19 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Durbtrade
//@version=5
// Durbtrade - Line Colorizer
indicator(title="Line Colorizer - Durbtrade", shorttitle="Line Colorizer - Durbtrade", timeframe="", overlay = true, timeframe_gaps=true, explicit_plot_zorder = true)
src1a = input(true, "Source 1", group="Sources", inline = "1")
src1b = input(close, title="", group="Sources", inline = "1")
src2a = input(false, "Source 2", group="Sources", inline = "2")
src2b = input(close, title="", group="Sources", inline = "2")
src3a = input(false, "Source 3", group="Sources", inline = "3")
src3b = input(close, title="", group="Sources", inline = "3")
src4a = input(false, "Source 4", group="Sources", inline = "4")
src4b = input(close, title="", group="Sources", inline = "4")
src5a = input(false, "Source 5", group="Sources", inline = "5")
src5b = input(close, title="", group="Sources", inline = "5")
src6a = input(false, "Source 6", group="Sources", inline = "6")
src6b = input(close, title="", group="Sources", inline = "6")
src7a = input(false, "Source 7", group="Sources", inline = "7")
src7b = input(close, title="", group="Sources", inline = "7")
src8a = input(false, "Source 8", group="Sources", inline = "8")
src8b = input(close, title="", group="Sources", inline = "8")
src9a = input(false, "Source 9", group="Sources", inline = "9")
src9b = input(close, title="", group="Sources", inline = "9")
src10a = input(false, "Source 10", group="Sources", inline = "10")
src10b = input(close, title="", group="Sources", inline = "10")
up = color.new(#17ff00, 0)
down = color.new(#ff0000, 0)
equal = color.new(#0300ff, 0)
plot(src1a == false ? na : src1b, "Colorized Source 1", color= src1b - src1b[1] >0 ? up: src1b - src1b[1] == 0 ? equal : down, linewidth = 2)
plot(src2a == false ? na : src2b, "Colorized Source 2", color= src2b - src2b[1] >0 ? up: src2b - src2b[1] == 0 ? equal : down, linewidth = 2)
plot(src3a == false ? na : src3b, "Colorized Source 3", color= src3b - src3b[1] >0 ? up: src3b - src3b[1] == 0 ? equal : down, linewidth = 2)
plot(src4a == false ? na : src4b, "Colorized Source 4", color= src4b - src4b[1] >0 ? up: src4b - src4b[1] == 0 ? equal : down, linewidth = 2)
plot(src5a == false ? na : src5b, "Colorized Source 5", color= src5b - src5b[1] >0 ? up: src5b - src5b[1] == 0 ? equal : down, linewidth = 2)
plot(src6a == false ? na : src6b, "Colorized Source 6", color= src6b - src6b[1] >0 ? up: src6b - src6b[1] == 0 ? equal : down, linewidth = 2)
plot(src7a == false ? na : src7b, "Colorized Source 7", color= src7b - src7b[1] >0 ? up: src7b - src7b[1] == 0 ? equal : down, linewidth = 2)
plot(src8a == false ? na : src8b, "Colorized Source 8", color= src8b - src8b[1] >0 ? up: src8b - src8b[1] == 0 ? equal : down, linewidth = 2)
plot(src9a == false ? na : src9b, "Colorized Source 9", color= src9b - src9b[1] >0 ? up: src9b - src9b[1] == 0 ? equal : down, linewidth = 2)
plot(src10a == false ? na : src10b, "Colorized Source 10", color= src10b - src10b[1] >0 ? up: src10b - src10b[1] == 0 ? equal : down, linewidth = 2)
// Durbtrade - Line Colorizer |
Monte Carlo Price Probabilities | https://www.tradingview.com/script/HLpRcHqT-Monte-Carlo-Price-Probabilities/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 83 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Monte Carlo", max_lines_count = 500, overlay = true, max_bars_back = 500)
arb_price = input.price(0, "Price", confirm = true)
sims = input.int(5, "Number of Sims", 1)
steps = input.int(5, "Number of steps into the future", 2)
accuracy = input.int(7, "Rounding Level")
lookback = input.int(0, "Start Bar Index", 0)
show_bar_index = input.bool(false, "Show Bar Index")
percent(a, b)=>
((a-b)/b) * 100
logReturn(a, b)=>
math.log(a / b) * 100
addLogReturn(number, logReturn) =>
result = number * math.exp(logReturn / 100)
result
movement_probability(accuracy)=>
var movement_size_green = array.new<float>(1)
var count_green = array.new<int>(1)
var movement_size_red = array.new<float>(1)
var count_red = array.new<int>(1)
var candle = array.new<int>(2, 0)
change = math.round(logReturn(close, close[1]), accuracy)
if close > open
if array.includes(movement_size_green, change)
index = array.indexof(movement_size_green, change)
array.set(count_green, index, array.get(count_green, index) + 1)
array.set(candle, 0, array.get(candle, 0) + 1)
else
array.push(movement_size_green, change)
array.push(count_green, 1)
array.set(candle, 0, array.get(candle, 0) + 1)
if close < open
if array.includes(movement_size_red, change)
index = array.indexof(movement_size_red, change)
array.set(count_red, index, array.get(count_red, index) + 1)
array.set(candle, 1, array.get(candle, 1) + 1)
else
array.push(movement_size_red, change)
array.push(count_red, 1)
array.set(candle, 1, array.get(candle, 1) + 1)
probability_green = array.new<float>(array.size(count_green))
probability_red = array.new<float>(array.size(count_red))
probability_can = array.new<float>(2)
count_green_sum = array.sum(count_green)
count_red_sum = array.sum(count_red)
count_can_sum = array.sum(candle)
for i = 0 to array.size(count_green) - 1
probability = array.get(count_green, i) / count_green_sum * 100
array.set(probability_green, i, probability)
for i = 0 to array.size(count_red) - 1
probability = array.get(count_red, i) / count_red_sum * 100
array.set(probability_red, i, probability)
for i = 0 to 1
probability = array.get(candle, i) / count_can_sum * 100
array.set(probability_can, i, probability)
[movement_size_green, movement_size_red, probability_green, probability_red, probability_can]
monte(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)=>
// Initialize the array to store the Monte Carlo simulation results
var monte_array = array.new<float>(steps)
// Loop through the number of steps
for i = 0 to steps - 1
// Generate a random number to determine if it's a green or red move
random_num_1 = math.random(0, 100, timenow)
// Check if the random number is less than or equal to the green candle probability
if random_num_1 <= array.get(probability_can, 0)
// Pick a green move size based on its probability
random_num = math.random(0, 100, timenow)
var cumulative_probability = 0.0
for j = 0 to array.size(probability_green) - 1
cumulative_probability := nz(cumulative_probability[1]) + array.get(probability_green, j)
if random_num <= cumulative_probability
// Get the corresponding green move size
move_size = array.get(movement_size_green, j)
// Add the move size to the monte_array
array.set(monte_array, i, move_size)
else
// Pick a red move size based on its probability
random_num = math.random(0, 100, timenow)
var cumulative_probability = 0.0
for j = 0 to array.size(probability_red) - 1
cumulative_probability := nz(cumulative_probability[1]) + array.get(probability_red, j)
if random_num <= cumulative_probability
// Get the corresponding red move size
move_size = array.get(movement_size_red, j)
// Add the move size to the monte_array
array.set(monte_array, i, move_size)
monte_array
sim(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can) =>
var simulation = array.new<float>(steps)
movements = monte(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)
for i = 1 to steps - 1
array.set(simulation, 0, open)
array.set(simulation, i, addLogReturn(array.get(simulation, i - 1), array.get(movements, i)))
simulation
probability_of_monte(arb_price, sims, steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)=>
var sucess = array.new<int>(sims)
output = array.new<float>(1)
if arb_price > open
for i = 0 to sims - 1
sim = sim(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)
if array.get(sim, steps - 1) >= arb_price
array.set(sucess, i, 1)
else
array.set(sucess, i, 0)
probability = array.sum(sucess)/sims * 100
else
for i = 0 to sims - 1
sim = sim(steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)
if array.get(sim, steps - 1) <= arb_price
array.set(sucess, i, 1)
else
array.set(sucess, i, 0)
probability = array.sum(sucess)/sims * 100
var label barindex = na
var line lines = na
var label price = na
if show_bar_index
barindex := label.new(bar_index + 1, arb_price, text = str.tostring(bar_index), style=label.style_label_down, textcolor = arb_price > open ? color.green : color.red, color=color.new(color.white, 100))
if bar_index > lookback
[movement_size_green, movement_size_red, probability_green, probability_red, probability_can] = movement_probability(accuracy)
probability = probability_of_monte(arb_price, sims, steps, movement_size_green, movement_size_red, probability_green, probability_red, probability_can)[1]
lines := line.new(bar_index + steps, arb_price, bar_index + steps + 1, arb_price, color = arb_price > open ? color.green : color.red)
price := label.new(bar_index + steps + 1, arb_price, text=str.tostring(math.round(probability, 2))+"%", style=label.style_label_down, textcolor = arb_price > open ? color.green : color.red, color=color.new(color.white, 100))
if barstate.isconfirmed
label.delete(price)
line.delete(lines)
label.delete(barindex) |
FVG Sessions [LuxAlgo] | https://www.tradingview.com/script/5ERKwGoq-FVG-Sessions-LuxAlgo/ | LuxAlgo | https://www.tradingview.com/u/LuxAlgo/ | 2,663 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo
//@version=5
indicator("FVG Sessions [LuxAlgo]", overlay = true, max_lines_count = 500, max_boxes_count = 500)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
bullCss = input.color(color.teal, 'FVG Level' , inline = 'bull')
bullAreaCss = input.color(color.new(color.teal, 50), 'Area' , inline = 'bull')
bullMitigatedCss = input.color(color.new(color.teal, 80), 'Mitigated', inline = 'bull')
bearCss = input.color(color.red, 'FVG Level' , inline = 'bear')
bearAreaCss = input.color(color.new(color.red, 50), 'Area' , inline = 'bear')
bearMitigatedCss = input.color(color.new(color.red, 80), 'Mitigated' , inline = 'bear')
//-----------------------------------------------------------------------------}
//UDT's
//-----------------------------------------------------------------------------{
type fvg
float top
float btm
bool mitigated
bool isnew
bool isbull
line lvl
box area
type session_range
line max
line min
//-----------------------------------------------------------------------------}
//Methods
//-----------------------------------------------------------------------------{
n = bar_index
//Method for setting fair value gaps
method set_fvg(fvg id, offset, bg_css, l_css)=>
avg = math.avg(id.top, id.btm)
area = box.new(n - offset, id.top, n, id.btm, na, bgcolor = bg_css)
avg_l = line.new(n - offset, avg, n, avg, color = l_css, style = line.style_dashed)
id.lvl := avg_l
id.area := area
//Method for setting session range maximum/minimum
method set_range(session_range id)=>
max = math.max(high, id.max.get_y2())
min = math.min(low, id.min.get_y2())
id.max.set_xy2(n, max)
id.max.set_y1(max)
id.min.set_xy2(n, min)
id.min.set_y1(min)
//-----------------------------------------------------------------------------}
//Variables
//-----------------------------------------------------------------------------{
var chartCss = color.new(chart.fg_color, 50)
var fvg sfvg = fvg.new(na, na, na, true, na)
var session_range sesr = na
var box area = na
var line avg = na
bull_fvg = low > high[2] and close[1] > high[2]
bear_fvg = high < low[2] and close[1] < low[2]
//Alert conditions
bull_isnew = false
bear_isnew = false
bull_mitigated = false
bear_mitigated = false
within_bull_fvg = false
within_bear_fvg = false
//-----------------------------------------------------------------------------}
//New session
//-----------------------------------------------------------------------------{
dtf = timeframe.change('D')
//On new session
if dtf
//Set delimiter
line.new(n, high + syminfo.mintick
, n, low - syminfo.mintick
, color = chartCss
, style = line.style_dashed
, extend = extend.both)
//Set new range
sesr := session_range.new(
line.new(n, high, n, high, color = chartCss)
, line.new(n, low, n, low, color = chartCss))
sfvg.isnew := true
//Set prior session fvg right coordinates
if not na(sfvg.lvl)
sfvg.lvl.set_x2(n-2)
sfvg.area.set_right(n-2)
//Set range
else if not na(sesr)
sesr.set_range()
//Set range lines color
sesr.max.set_color(sfvg.isbull ? bullCss : bearCss)
sesr.min.set_color(sfvg.isbull ? bullCss : bearCss)
//-----------------------------------------------------------------------------}
//Set FVG
//-----------------------------------------------------------------------------{
//New session bullish fvg
if bull_fvg and sfvg.isnew
sfvg := fvg.new(low, high[2], false, false, true)
sfvg.set_fvg(2, bullAreaCss, bullCss)
bull_isnew := true
//New session bearish fvg
else if bear_fvg and sfvg.isnew
sfvg := fvg.new(low[2], high, false, false, false)
sfvg.set_fvg(2, bearAreaCss, bearCss)
bear_isnew := true
//Change object transparencies if mitigated
if not sfvg.mitigated
//If session fvg is bullish
if sfvg.isbull and close < sfvg.btm
sfvg.set_fvg(1, bullMitigatedCss, bullCss)
sfvg.mitigated := true
bull_mitigated := true
//If session fvg is bearish
else if not sfvg.isbull and close > sfvg.top
sfvg.set_fvg(1, bearMitigatedCss, bearCss)
sfvg.mitigated := true
bear_mitigated := true
//Set fvg right coordinates to current bar
if not sfvg.isnew
sfvg.lvl.set_x2(n)
sfvg.area.set_right(n)
//-----------------------------------------------------------------------------}
//Alerts
//-----------------------------------------------------------------------------{
//On new session fvg
alertcondition(bull_isnew, 'Bullish FVG', 'New session bullish fvg')
alertcondition(bear_isnew, 'Bearish FVG', 'New session bearish fvg')
//On fvg mitigation
alertcondition(bull_mitigated, 'Mitigated Bullish FVG', 'Session bullish fvg has been mitigated')
alertcondition(bear_mitigated, 'Mitigated Bearish FVG', 'Session bearish fvg has been mitigated')
//If within fvg
alertcondition(close >= sfvg.btm and close <= sfvg.top and sfvg.isbull and not sfvg.isnew
, 'Price Within Bullish FVG'
, 'Price is within bullish fvg')
alertcondition(close >= sfvg.btm and close <= sfvg.top and not sfvg.isbull and not sfvg.isnew
, 'Price Within Bearish FVG'
, 'Price is within bearish fvg')
//On fvg average cross
alertcondition(ta.cross(close, math.avg(sfvg.top, sfvg.btm)) and sfvg.isbull and not sfvg.isnew
, 'Bullish FVG AVG Cross'
, 'Price crossed bullish fvg average')
alertcondition(ta.cross(close, math.avg(sfvg.top, sfvg.btm)) and not sfvg.isbull and not sfvg.isnew
, 'Bearish FVG AVG Cross'
, 'Price crossed bearish fvg average')
//-----------------------------------------------------------------------------} |
Trend Angle | https://www.tradingview.com/script/XtMt3LBp-Trend-Angle/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 91 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Trend Angle")
length = input.int(8, "Length", 1)
scale = input.int(2, "Scale", 1)
smooth = input.float(2, "Smooting", 1)
factor = input.float(1, "Smoothing Factor", 0.125, 100, 0.125)
ema(source)=>
var float ema = 0.0
var int count = 0
count := nz(count[1]) + 1
ema := (1.0 - 2.0 / (count + 1.0)) * nz(ema[1]) + 2.0 / (count + 1.0) * source
ema
atan2(y, x) =>
var float angle = 0.0
if x > 0
angle := math.atan(y / x)
else
if x < 0 and y >= 0
angle := math.atan(y / x) + math.pi
else
if x < 0 and y < 0
angle := math.atan(y / x) - math.pi
else
if x == 0 and y > 0
angle := math.pi / 2
else
if x == 0 and y < 0
angle := -math.pi / 2
angle
degrees(float source) =>
source * 180 / math.pi
// Epanechnikov kernel function
epanechnikov_kernel(_src, _size, _h, _r) =>
_currentWeight = 0.0
_cumulativeWeight = 0.0
for i = 0 to _size
y = _src[i]
u = math.pow(i, 2) / (math.pow(_h, 2) * _r)
w = (u >= 1) ? 0 : (3. / 4) * (1 - math.pow(u, 2))
_currentWeight := _currentWeight + y * w
_cumulativeWeight := _cumulativeWeight + w
_currentWeight / _cumulativeWeight
atr = ema(ta.tr)
slope = (close - close[length]) / (atr/(length/scale) * length)
angle_rad = atan2(slope, 1)
degrees = epanechnikov_kernel(degrees(angle_rad), length, smooth, factor)
plot(degrees, "Trend Angle", color.orange)
hline(0)
hline(90, linestyle = hline.style_solid)
hline(-90, linestyle = hline.style_solid) |
Fetch ATR + MA Strategy | https://www.tradingview.com/script/bka1NUXf-Fetch-ATR-MA-Strategy/ | FetchTeam | https://www.tradingview.com/u/FetchTeam/ | 34 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © FetchTeam
//@version=5
indicator("Fetch ATR + MA Strategy", overlay=true)
ATR_COLOR = input.color(color.red, "ATR COLOR")
MA_COLOR = input.color(color.new(#c732b0, 1))
MA_INPUT = input(defval=20, title='ATR MA')
SHORT_MA_INPUT = input(defval=50, title='Short Ma')
LONG_MA_INPUT = input(defval=200, title='Short Ma')
SHOW_SELL_SIGNALS = input.bool(true, "Show Sell Signals")
ATR = ta.atr(14)
[DI_PLUS, DI_MINUS, ADX] = ta.dmi(14, 14)
MOVING_AVERAGE_OF_ATR = ta.sma(ATR, MA_INPUT)
SHORT_MA = ta.sma(close, SHORT_MA_INPUT)
LONG_MA = ta.sma(close, LONG_MA_INPUT)
CROSS_OVER = ta.crossover(SHORT_MA, LONG_MA)
CROSS_UNDER = ta.crossunder(SHORT_MA, LONG_MA)
BUY_SIGNAL = 0
if (CROSS_OVER and ATR < MOVING_AVERAGE_OF_ATR)
if ADX < 30
BUY_SIGNAL := 1
plotshape(series=BUY_SIGNAL ? BUY_SIGNAL == 1 : na, location=location.abovebar, style=shape.diamond, color=color.green, size=size.small)
plotshape(series=CROSS_UNDER ? SHOW_SELL_SIGNALS == true : na, location=location.abovebar, style=shape.diamond, color=color.red, size=size.small)
|
SuperBollingerTrend (Expo) | https://www.tradingview.com/script/AjWfiZpw-SuperBollingerTrend-Expo/ | Zeiierman | https://www.tradingview.com/u/Zeiierman/ | 4,967 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Zeiierman
//@version=5
indicator("SuperBollingerTrend (Expo)","",true,max_labels_count = 500)
//~~ Inputs {
int prd = input.int(12,"Period",minval=1,inline="setting")
float mult = input.float(2.0,"Mult",minval=0.1,step=.1,inline="setting", tooltip = "Set the Bollinger Band period. \n\nSet the multiplier.")
bool showZigZag = input.bool(true,"ZigZag",inline="zigzag")
string signal = input.string("Signal","",["Signal","Peak Distance"],inline="zigzag")
string dev = input.string("ZigZag","",["ZigZag","High/Low","Close"],inline="zigzag", tooltip = "Enable the ZigZag Bollinger Signals. \n\nSelect if you only want to display the signals or the Peak Signal Distance between each signal. \n\nThe Signal Distance can be calculated using the ZigZag, High/Low, or Close.")
bool showTable = input.bool(false,"Average/Median Distance",inline="", tooltip = "Enable the Table that displays the Average or Median ZigZag move.")
bool showTP = input.bool(false,"Take Profit",inline="tp")
string Tp = input.string("Median","",["Median","Average"],inline="tp", tooltip = "Enable the Take-Profit line. \n\nSelect if the TP should be based on the Average or Median move.")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Types & Variables {
//Types
type ZigZag
int [] x1
float [] y1
float [] diff
type SuperBollingerTrend
float s
color c
type Alerts
bool Long = false
bool Short = false
bool LongTp = false
bool ShortTp = false
var zz = ZigZag.new(array.new<int>(),array.new<float>(),array.new<float>())
var sbt = SuperBollingerTrend.new(0.0,na)
alerted = Alerts.new()
//Variables
int b = bar_index
float bbup = ta.sma(high,prd)+ta.stdev(high,prd)*mult
float bbdn = ta.sma(low,prd)-ta.stdev(low,prd)*mult
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Methods{
//ZigZag
method zigzag(ZigZag z,c,p,l)=>
y2 = dev=="ZigZag"?sbt.s:
dev=="High/Low"?p:
close
if z.x1.size()>0
x1 = z.x1.get(0)
y1 = z.y1.get(0)
z.diff.unshift(math.abs(y2-y1))
line.new(x1,y1,b,y2,color=color.new(color.gray,0),style=line.style_dashed)
style = signal=="Signal"?(l?label.style_triangleup:label.style_triangledown) :
(l?label.style_label_up:label.style_label_down)
txt = signal=="Signal"?na : str.tostring(y2-y1,format.mintick)+"p"
label.new(b,sbt.s,txt,color=c,size=size.small,style=style,textcolor=chart.bg_color)
z.x1.unshift(b)
z.y1.unshift(y2)
//SuperBollingerTrend Calculation
method SBT(SuperBollingerTrend s,cond,val,col,p,l)=>
s.s := na(bbdn) or na(bbup)?0.0 : close>sbt.s?math.max(sbt.s,bbdn) : close<sbt.s?math.min(sbt.s,bbup) : 0.0
if cond
s.s := val
s.c := col
if showZigZag
zz.zigzag(col,p,l)
alerted.Long := l?true:false
alerted.Short := l?false:true
//Run Methods
sbt.SBT(ta.crossover(close,sbt.s),bbdn,color.lime,low,true)
sbt.SBT(ta.crossunder(close,sbt.s),bbup,color.red,high,false)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Plot & Table {
//Plot
plot(sbt.s,"SuperBollingerTrend",sbt.c)
//TP Line
var tp = line.new(na,na,na,na,color=color.lime)
var ltp = label.new(na,na,"TP",color=color(na),style=label.style_label_left,textcolor=chart.fg_color,size=size.normal)
dist = Tp=="Median"?zz.diff.median():zz.diff.avg()
if showTP and zz.y1.size()>0
pos = close>sbt.s?true:false
x = zz.x1.get(0)
y = pos?zz.y1.get(0)+dist:zz.y1.get(0)-dist
tp.set_xy1(x,y)
tp.set_xy2(b+10,y)
ltp.set_xy(b+10,y)
alerted.LongTp := pos?high>=y and high[1]<y:false
alerted.ShortTp := pos?false:low<=y and low[1]>y
//Table
var table tbl = na
if barstate.islast and showZigZag and showTable
tbl := table.new(position.top_right, 1, 1, chart.bg_color,
frame_color=color.new(color.gray,50), frame_width=3, border_width=1)
tbl.cell(0,0,Tp=="Median"?"Median ZigZag Distance: "+str.tostring(dist,format.mintick)+"p":"Avg ZigZag Distance: "+str.tostring(dist,format.mintick)+"p",text_color=chart.fg_color)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Alerts {
alertcondition(alerted.Long,"Long Alert","Long Signal")
alertcondition(alerted.Short,"Short Alert","Short Signal")
alertcondition(alerted.LongTp,"Long TP Alert","Long TP")
alertcondition(alerted.ShortTp,"Short TP Alert","Short TP")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~} |
libhs.log.DEMO | https://www.tradingview.com/script/wITCQP6R-libhs-log-DEMO/ | GETpacman | https://www.tradingview.com/u/GETpacman/ | 2 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © GETpacman
//@version=5
indicator("libhs.logger.DEMO", overlay=true)
plot(na)
import GETpacman/logger/3 as logger
import GETpacman/libhs_td4/3 as td4
import GETpacman/libhs_td5/3 as td5
color c_cream =color.new(#c29857,20)
ip_consoleFirst =input.bool(true,'Test Console First?')
ip_uat_show=true
ip_uat_pos = input.string ('Bottom Right','Position', inline='22', group='UAT', options=['Top Left','Top Center','Top Right','Middle Left','Middle Center','Middle Right','Bottom Left','Bottom Center','Bottom Right'])
ip_uat_width = input.int (80, 'Width', inline='22', group='UAT', minval=20, maxval=400, step=10)
ip_uat_hsize = input.string ('Auto', 'UAT Header', inline='25', group='UAT', options=['Auto','Tiny','Small','Normal','Large','Huge'])
ip_uat_hhalign = input.string ('Left', 'HA', inline='25', group='UAT', options=['Left','Center','Right'])
ip_uat_hvalign = input.string ('Top', 'VA', inline='25', group='UAT', options=['Top','Center','Bottom'])
ip_uat_tsize = input.string ('Auto', 'UAT Text', inline='26', group='UAT', options=['Auto','Tiny','Small','Normal','Large','Huge'])
ip_uat_thalign = input.string ('Left', 'HA', inline='26', group='UAT', options=['Left','Center','Right'])
ip_uat_tvalign = input.string ('Top', 'VA', inline='26', group='UAT', options=['Top','Center','Bottom'])
pos_uat = ip_uat_pos.getTablePosition()
hsize_uat = ip_uat_hsize.getTextSize()
hhalign_uat = ip_uat_hhalign.getTextAlign()
hvalign_uat = ip_uat_hvalign.getTextAlign()
tsize_uat = ip_uat_tsize.getTextSize()
thalign_uat = ip_uat_thalign.getTextAlign()
tvalign_uat = ip_uat_tvalign.getTextAlign()
var int maxLog=5
var int __colors=36
var demo = logger.log.new()
demo.init(maxLog, ip_consoleFirst? true:false)
var consoleBus = matrix.new<string>(500,40,'')
var logxBus = matrix.new<string>(500,40,'')
TsizeSmall='small'
TsizeNormal='normal'
L_bottom_center='bottom center'
td4.fill(consoleBus,fillData=barstate.isfirst)
td5.fill(logxBus,fillData=barstate.isfirst)
int devcolmsg=2, int devcollevelC=3, int devcolstatusC=4, int prodcolmsg=5, int prodcollevelC=6, int prodcolstatusC=7
int devcolm1=8, int devcolm2=9, int devcolm3=10, int devcolm4=11, int devcolm5=12, int devcolm6=13, int devcollevelL=14, int devcolstatusL=15
int prodcolm1=16, int prodcolm2=17, int prodcolm3=18, int prodcolm4=19, int prodcolm5=20, int prodcolm6=21, int prodcollevelL=22, int prodcolstatusL=23
var string o_skiplog = '^skip^'
color c_fuchsia_t100 = color.new(color.fuchsia,0)
color c_fuchsia_t65 = color.new(color.fuchsia,35)
color c_fuchsia_t35 = color.new(color.fuchsia,65)
color c_olive_t100 = color.new(color.olive,0)
color c_olive_t65 = color.new(color.olive,35)
color c_olive_t35 = color.new(color.olive,65)
color c_maroon_t100 = color.new(color.maroon,0)
color c_maroon_t65 = color.new(color.maroon,35)
color c_maroon_t35 = color.new(color.maroon,65)
color c_navy_t100 = color.new(color.navy,0)
color c_navy_t65 = color.new(color.navy,35)
color c_navy_t35 = color.new(color.navy,65)
color[] customFG=array.new_color()
color[] customHC=array.new_color()
array.push(customFG,color.orange), array.push(customHC,color.white)
array.push(customFG,c_fuchsia_t100), array.push(customHC,color.white)
array.push(customFG,c_fuchsia_t65), array.push(customHC,color.white)
array.push(customFG,c_olive_t100), array.push(customHC,color.white)
array.push(customFG,c_olive_t65), array.push(customHC,color.white)
array.push(customFG,c_maroon_t100), array.push(customHC,color.white)
array.push(customFG,c_maroon_t65), array.push(customHC,color.white)
array.push(customFG,c_navy_t100), array.push(customHC,color.white)
array.push(customFG,c_navy_t65), array.push(customHC,color.white)
array.push(customFG,c_fuchsia_t35), array.push(customHC,color.white)
array.push(customFG,c_olive_t35), array.push(customHC,color.white)
array.push(customFG,c_maroon_t35), array.push(customHC,color.white)
array.push(customFG,c_navy_t35), array.push(customHC,color.white)
int offsetErrorBars=1
var int xbarFinalTestDone=318+9
var int cbarFinalTestDone=321
var int abarFinalTestDone=28
var int totalFinalTestDone=xbarFinalTestDone+cbarFinalTestDone+abarFinalTestDone
int zidx=bar_index>(offsetErrorBars-1)?(((bar_index-offsetErrorBars)%totalFinalTestDone)+1):0
int idza= zidx - cbarFinalTestDone - xbarFinalTestDone
int idzc= (idza > 0) ? (cbarFinalTestDone+idza) : (zidx - (ip_consoleFirst ? 0 : xbarFinalTestDone))
int idzx= (idza > 0) ? (xbarFinalTestDone+idza) : (zidx - (ip_consoleFirst ? cbarFinalTestDone : 0))
var int zx=0
var int zc=0
var int za=0
var int czx=0
var int czc=0
var int cza=0
bool showLogx = ip_uat_show and bar_index>(offsetErrorBars-1) and (idzx>=1 and idzx<=xbarFinalTestDone)
bool showConsole= ip_uat_show and bar_index>(offsetErrorBars-1) and (idzc>=1 and idzc<=cbarFinalTestDone)
bool showAttachedConsole=ip_uat_show and bar_index>(offsetErrorBars-1) and ((idza>=1 and idza<=5) or (idza>=26 and idza<=abarFinalTestDone)) and zidx>=(totalFinalTestDone-(xbarFinalTestDone+cbarFinalTestDone))
bool consoleAttached=ip_uat_show and bar_index>(offsetErrorBars-1) and (idza>5 and idza<26) and zidx>=(totalFinalTestDone-(xbarFinalTestDone+cbarFinalTestDone))
gm='', gm1='', gm2='', gm3='', gm4='', gm5='', gm6='', gs=''
dbmsg='', dbLevelC='', dbStatusC=''
dbm1='', dbm2='', dbm3='', dbm4='', dbm5='', dbm6='', dbLevelL='', dbStatusL=''
//______ == ______________________________ TESTING Logx
if idzx==1 or barstate.isfirst
zx:=1
demo.IsConsole:=false
demo.clear()
demo.resize(maxLog)
demo.resetFrameColor()
demo.PageOnEveryBar := false
demo.MoveLogUp := true
demo.ColorText := false
demo.HighlightText := false
demo.ShowBarIndex := false
demo.ShowDateTime := false
demo.ShowLogLevels :=false
demo.ReplaceWithCodes:=false
demo.ShowHeader := true
demo.HeaderAtTop := true
demo.StatusBarAtBottom := true
demo.ShowStatusBar := true
demo.ShowMetaStatus := true
demo.ShowQ1:=true, demo.ShowQ2:=true, demo.ShowQ3:=true, demo.ShowQ4:=true, demo.ShowQ5:=true, demo.ShowQ6:=true
demo.TabSizeQ1:=0, demo.TabSizeQ2:=0, demo.TabSizeQ3:=0, demo.TabSizeQ4:=0, demo.TabSizeQ5:=0, demo.TabSizeQ6:=0
demo.HeaderQ1:='logx.q1', demo.HeaderQ2:='logx.q2', demo.HeaderQ3:='logx.q3', demo.HeaderQ4:='logx.q4', demo.HeaderQ5:='logx.q5', demo.HeaderQ6:='logx.q6'
demo.AutoMerge := true
demo.dateTimeFormat('dd.MMM.yy HH:mm')
demo.FrameColor :=color.green
demo.MarkNewBar := false
demo.PageHistory := 0
demo.RestrictLevelsToKey7 := false
demo.MinWidth := 80
demo.StatusTooltip :='Logx Testing'
demo.ShowMinimumLevel:= 0
czx+=1
if idzx==1 or idzx==61 or idzx==73 or idzx==85 or idzx==96 or idzx==123 or idzx==203 or idzx==243 or idzx==245 or idzx==246 or idzx==304 or idzx==310 or idzx==320
czx:=0
if idzx==305
czx:=8
ezx=((czx-1)%__colors)+1
switch(idzx) //Prep resize and clear
66 => demo.resize(12)
133 => demo.resize(5)
142 => demo.clear()
// 152 => demo.clear()
154 => demo.clear()
167 => demo.resize(6)
168 => demo.resize(5)
170 => demo.resize(15)
198 => demo.clear()
207 => demo.resize(11)
231 => demo.resize(20)
242 => demo.resize(11)
245 => demo.resize(12)
247 => demo.resize(10)
278 => demo.resize(7)
302 => demo.clear(), demo.resize(15)
308 => demo.resize(18)
switch(idzx) //PreCalls #1
18 => demo.resetFrameColor()
70 => demo.ColorText := false
82 => demo.HighlightText := false
93 => demo.ColorText := false
104 => demo.HighlightText := false
129 => demo.StatusBarAtBottom := true
134 => demo.HeaderAtTop := true
142 => demo.StatusBarAtBottom := false
154 => demo.MoveLogUp := true
162 => demo.dateTimeFormat()
167 => demo.PageHistory := 0
173 => demo.PageOnEveryBar := false
184 => demo.AutoMerge := false
186 => demo.PageHistory := 0
192 => demo.AutoMerge := false
198 => demo.ShowQ1:=true, demo.ShowQ2:=true, demo.ShowQ3:=true, demo.ShowQ4:=true, demo.ShowQ5:=true, demo.ShowQ6:=true
210 => demo.AutoMerge := true
211 => demo.TabSizeQ1:=0, demo.TabSizeQ2:=0, demo.TabSizeQ3:=0
228 => demo.ShowStatusBar := true
229 => demo.ShowBarIndex := false
234 => demo.MarkNewBar := false
240 => demo.MinWidth := 80
247 => demo.RestrictLevelsToKey7 := false
255 => demo.ShowBarIndex := false
304 => demo.ColorText := true
305 => demo.ColorText := false
308 => demo.ShowMinimumLevel := 0
switch(idzx) //Prep Calls #2
154 => demo.StatusBarAtBottom := true
165 => demo.ShowDateTime := false
228 => demo.ShowMetaStatus := true
240 => demo.ShowBarIndex := true
279 => demo.ColorText := true
300 => demo.ColorText := false
321 => demo.ColorText := true
322 => demo.ColorText := false
switch (idzx) // Main Calls via => On Next Bar Call
8 => demo.resize(10)
16 => demo.resize(7)
21 => demo.TextColor :=color.blue
25 => demo.TextColorBG := color.orange
29 => demo.resetTextColorBG()
33 => demo.resetTextColor()
37 => demo.StatusColor :=color.green
41 => demo.StatusColorBG :=color.white
45 => demo.resetStatusColorBG()
49 => demo.resetStatusColor()
53 => demo.FrameColor :=color.green
57 => demo.resetFrameColor()
61 => demo.setColors(customFG)
62 => demo.ColorText := true
73 => demo.setColorsHC(customHC)
74 => demo.HighlightText := true
85 => demo.resetColors()
86 => demo.ColorText := true
95 => demo.resetColorsHC()
96 => demo.HighlightText := true
114 => demo.setLevelName(40,'Custom Code 40')
116 => demo.setColor(36,color.red)
118 => demo.setColorHC(40,color.black), demo.setColor(40,color.orange)
121 => demo.setColorBG(41,color.yellow)
126 => demo.StatusBarAtBottom := false
131 => demo.HeaderAtTop := false
136 => demo.ShowHeader := false
142 => demo.MoveLogUp := false
154 => demo.ShowHeader := true, demo.setFontHeader(font.family_monospace)
156 => demo.ShowBarIndex := true
160 => demo.ShowDateTime := true
162 => demo.dateTimeFormat('dd.MMM.yy')
164 => demo.dateTimeFormat('')
167 => demo.PageOnEveryBar := true, demo.setFontHeader()
170 => demo.PageHistory := 1
186 => demo.ShowQ2:=false, demo.ShowQ6:=false
189 => demo.ShowQ2:=true, demo.ShowQ6:=true
190 => demo.ShowQ3:=false, demo.ShowQ5:=false
199 => demo.AutoMerge := true
203 => demo.TabSizeQ1:=1, demo.TabSizeQ2:=2, demo.TabSizeQ3:=3
217 => demo.Status:="Look we have a status message now, that will persist across updates", demo.setFontStatus(font.family_monospace), demo.setFontMetaStatus(font.family_monospace)
223 => demo.ShowMetaStatus := false, demo.setFontStatus(),demo.setFontMetaStatus()
226 => demo.ShowStatusBar := false
231 => demo.MarkNewBar := true
238 => demo.MinWidth := 200
244 => demo.ShowLogLevels := true
245 => demo.RestrictLevelsToKey7 :=true
247 => demo.ReplaceWithCodes:=true
249 => demo.ShowLogLevels := false
256 => demo.IsConsole := true
262 => demo.IsConsole := false
272 => demo.turnPage()
305 => demo.ShowMinimumLevel := 3
306 => demo.ShowMinimumLevel := 4
312 => demo.undo()
313 => demo.undo(3)
314 => demo.undo(16)
322 => demo.undo2()
323 => demo.undo1(2)
324 => demo.undo2(20)
if (idzx>=1 and idzx<167 ) or (idzx>172 and idzx<178 ) or (idzx>180 and idzx<231 ) or (idzx>233 and idzx<255 ) or (idzx>261 and idzx<279 ) or (idzx>299 and idzx<304) or (idzx>304 and idzx<312 and idzx!=311) or (idzx>314 and idzx<321) or (idzx>324 and idzx<=xbarFinalTestDone and (idzx!=244 or idzx!=247))
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if idzx==167
for x=1 to 6
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if (idzx>=168 and idzx<=172 )
for x=1 to 5
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if (idzx>=178 and idzx<=180 )
for x=1 to 6
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.page(ezx,gm1,gm2,gm3,gm4,gm5,gm6, page=gm1!=o_skiplog)
zx+=1
if (idzx>=231 and idzx<=233 )
for x=1 to 4
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if (idzx==244 or idzx==247 )
for x=1 to 9
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx+x,gm1,gm2,gm3,gm4,gm5,gm6,font=font.family_monospace, log=gm1!=o_skiplog)
zx+=1
if (idzx>=255 and idzx<=261)
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx,m1=gm1+gm2+gm3+gm4+gm5+gm6, log=gm1!=o_skiplog)
zx+=1
if idzx==279
for x=1 to 5
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log1(ezx,gm1,cq=2, log=gm1!=o_skiplog)
zx+=1
if (idzx>=280 and idzx<=286) or (idzx>=291 and idzx<=299)
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log2(ezx,gm2,cq=3, log=gm2!=o_skiplog)
zx+=1
if (idzx>=287 and idzx<=290)
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log3(ezx,gm3,cq=4, log=gm3!=o_skiplog)
zx+=1
if idzx==304
for x=0 to 7
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx+x,ezx+x+10,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if idzx==311
for x=1 to 15
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log(ezx+x,ezx+x,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zx+=1
if idzx==321
for x=1 to 5
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log1(ezx,gm1,cq=4, log=gm1!=o_skiplog)
zx+=1
for x=1 to 7
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log2(ezx,gm2,cq=5, log=gm2!=o_skiplog)
zx+=1
for x=1 to 4
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log3(ezx,gm3,cq=6, log=gm3!=o_skiplog)
zx+=1
for x=1 to 3
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6), gs:=logxBus.get(zx,prodcolstatusL), demo.log2(ezx,gm2,cq=7, log=gm2!=o_skiplog)
zx+=1
if (idzx>=1 and idzx<167 )
demo.Status:=logxBus.get(zx-1,prodcolstatusL)
else if not(idzx>=217 and idzx<=219 ) and (idzx>=1 and idzx<=xbarFinalTestDone)
demo.Status:=logxBus.get(zx-1,prodcolstatusL)
//______ xx ______________________________ TESTING Logx
//______ == ______________________________ TESTING Console
if idzc==1 or barstate.isfirst
zc:=1
demo.IsConsole:=true
demo.clear()
demo.resize(maxLog)
demo.resetFrameColor()
demo.PageOnEveryBar := false
demo.MoveLogUp := true
demo.ColorText := false
demo.HighlightText := false
demo.ShowBarIndex := false
demo.ShowDateTime := false
demo.ShowLogLevels :=false
demo.ReplaceWithCodes:=false
demo.ShowHeader := true
demo.HeaderAtTop := true
demo.StatusBarAtBottom := true
demo.ShowStatusBar := true
demo.ShowMetaStatus := true
demo.ShowQ1:=true, demo.ShowQ2:=true, demo.ShowQ3:=true, demo.ShowQ4:=true, demo.ShowQ5:=true, demo.ShowQ6:=true
demo.TabSizeQ1:=0, demo.TabSizeQ2:=0, demo.TabSizeQ3:=0, demo.TabSizeQ4:=0, demo.TabSizeQ5:=0, demo.TabSizeQ6:=0
demo.HeaderQ1:='s.q1', demo.HeaderQ2:='s.q2', demo.HeaderQ3:='s.q3', demo.HeaderQ4:='s.q4', demo.HeaderQ5:='s.q5', demo.HeaderQ6:='s.q6'
demo.AutoMerge := true
demo.dateTimeFormat('dd.MMM.yy HH:mm')
demo.FrameColor :=color.blue
demo.MarkNewBar := false
demo.MinWidth := 80
demo.PageHistory := 0
demo.RestrictLevelsToKey7 := false
demo.StatusTooltip :='Console Testing'
demo.ShowMinimumLevel:= 0
czc+=1
if idzc==1 or idzc==61 or idzc==73 or idzc==85 or idzc==96 or idzc==189 or idzc==307 or idzc==310
czc:=0
if idzc==308
czc:=8
ezc=((czc-1)%__colors)+1
switch(idzc) //Prep resize and clear
66 => demo.resize(12)
147 => demo.resize(5), demo.clear()
159 => demo.clear()
171 => demo.resize(6)
175 => demo.resize(15)
200 => demo.clear(), demo.resize(26), demo.FrameColor:=color.blue
233 => demo.resize(30)
243 => demo.resize(8)
295 => demo.clear(), demo.resize(24), demo.FrameColor:=color.blue
305 => demo.clear()
311 => demo.resize(18)
switch(idzc) //PreCalls #1
18 => demo.resetFrameColor()
70 => demo.ColorText := false
82 => demo.HighlightText := false
93 => demo.ColorText := false
104 => demo.HighlightText := false, demo.ShowLogLevels:=false
128 => demo.StatusBarAtBottom := true
143 => demo.ShowMetaStatus := true
147 => demo.StatusBarAtBottom := false
159 => demo.MoveLogUp := true
169 => demo.ShowDateTime := false
170 => demo.FrameColor := color.blue
178 => demo.PageOnEveryBar := false, demo.resetFrameColor()
190 => demo.PageHistory := 0
198 => demo.TabSizeQ1:=0
230 => demo.resetFrameColor()
236 => demo.MarkNewBar := false
242 => demo.MinWidth := 80
310 => demo.ShowMinimumLevel := 0
switch(idzc) //Prep Calls #2
143 => demo.ShowStatusBar := true
159 => demo.StatusBarAtBottom := true
170 => demo.ShowBarIndex := false
198 => demo.PrefixLogLevel := false
switch (idzc) // Main Calls via => On Next Bar Call
8 => demo.resize(10)
16 => demo.resize(7)
21 => demo.TextColor :=color.blue
25 => demo.TextColorBG := color.orange
29 => demo.resetTextColorBG()
33 => demo.resetTextColor()
37 => demo.StatusColor :=color.green
41 => demo.StatusColorBG :=color.white
45 => demo.resetStatusColorBG()
49 => demo.resetStatusColor()
53 => demo.FrameColor :=color.blue
57 => demo.resetFrameColor()
61 => demo.setColors(customFG)
62 => demo.ColorText := true
73 => demo.setColorsHC(customHC)
74 => demo.HighlightText := true
85 => demo.resetColors()
86 => demo.ColorText:= true, demo.ShowLogLevels:=true
95 => demo.resetColorsHC()
96 => demo.HighlightText := true
114 => demo.setLevelName(40,'Custom Code 40')
116 => demo.setColor(36,color.red)
118 => demo.setColorHC(40,color.black), demo.setColor(40,color.orange)
121 => demo.setColorBG(41,color.yellow)
126 => demo.StatusBarAtBottom := false
133 => demo.Status:="Look we have a status message now, that will persist across updates", demo.setFontStatus(font.family_monospace)
136 => demo.Status:=""
139 => demo.ShowMetaStatus := false, demo.setFontStatus()
142 => demo.ShowStatusBar :=false
147 => demo.MoveLogUp := false
161 => demo.ShowBarIndex := true
165 => demo.ShowDateTime := true
167 => demo.dateTimeFormat('dd.MMM.yy')
169 => demo.dateTimeFormat('')
172 => demo.PageOnEveryBar := true
175 => demo.PageHistory := 1
190 => demo.PrefixLogLevel := true
191 => demo.TabSizeQ1:=1
233 => demo.MarkNewBar := true
240 => demo.MinWidth := 200
246 => demo.IsConsole := false
255 => demo.IsConsole := true
265 => demo.turnPage()
308 => demo.ShowMinimumLevel := 3
309 => demo.ShowMinimumLevel := 4
315 => demo.undo()
316 => demo.undo(3)
317 => demo.undo(16)
if (idzc>=1 and idzc<172 ) or (idzc>177 and idzc<183 ) or (idzc>185 and idzc<233 ) or (idzc>235 and idzc<250 ) or (idzc>252 and idzc<272) or (idzc>289 and idzc<295) or (idzc>302 and idzc<=306) or (idzc>=308 and idzc<314) or (idzc>317 and idzc<=cbarFinalTestDone)
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if idzc==172
for x=1 to 6
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if (idzc>=173 and idzc<=177)
for x=1 to 5
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if (idzc>=183 and idzc<=185)
for x=1 to 6
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.page(ezc,gm1,gm2,gm3,gm4,gm5,gm6, page=gm1!=o_skiplog)
zc+=1
if (idzc>=233 and idzc<=235)
for x=1 to 4
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if (idzc>=250 and idzc<=252)
gm1:=consoleBus.get(zc,prodcolm1), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if idzc==272
for x=1 to 5
gm1:=consoleBus.get(zc,prodcolm1), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm1,1, log=gm1!=o_skiplog)
zc+=1
if (idzc>=273 and idzc<=279) or (idzc>=284 and idzc<=289)
gm1:=consoleBus.get(zc,prodcolm1), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm2,2, log=gm2!=o_skiplog)
zc+=1
if (idzc>=280 and idzc<=283)
gm1:=consoleBus.get(zc,prodcolm1), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm3,3, log=gm3!=o_skiplog)
zc+=1
if idzc==295
for x=1 to 23
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm2,2, log=gm2!=o_skiplog)
zc+=1
if idzc==296
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm2,2, log=gm2!=o_skiplog)
zc+=1
if (idzc>=297 and idzc<=302)
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.alog(ezc,gm1,1, log=gm1!=o_skiplog)
zc+=1
if idzc==307
for x=0 to 7
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc+x,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if idzc==314
for x=1 to 15
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6), gs:=consoleBus.get(zc,prodcolstatusC), demo.log(ezc+x,ezc+x,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog)
zc+=1
if (idzc>=1 and idzc<123) and (idzc>135 and idzc<167)
demo.Status:=consoleBus.get(zc-1,prodcolstatusC)
else if not(idzc>=133 and idzc<=135) and (idzc>=1 and idzc<=cbarFinalTestDone)
demo.Status:=consoleBus.get(zc-1,prodcolstatusC)
//______ xx ______________________________ TESTING Console
//______ == ______________________________ TESTING Attachment of Console to Logx
var console = logger.log.new()
console.init(maxLog,true)
if idza==-6
demo.resize(15)
if idza==1 or barstate.isfirst
za:=1
console.IsConsole:=true
console.clear()
console.resize(5)
console.FrameColor := color.maroon
console.PageOnEveryBar := false
console.MoveLogUp := true
console.ColorText := false
console.HighlightText := false
console.ShowBarIndex := false
console.ShowDateTime := false
console.ShowLogLevels :=false
console.ReplaceWithCodes:=false
console.ShowHeader := true
console.HeaderAtTop := true
console.StatusBarAtBottom := true
console.ShowStatusBar := true
console.ShowMetaStatus := true
console.ShowQ1:=true, console.ShowQ2:=true, console.ShowQ3:=true, console.ShowQ4:=true, console.ShowQ5:=true, console.ShowQ6:=true
console.TabSizeQ1:=0, console.TabSizeQ2:=0, console.TabSizeQ3:=0, console.TabSizeQ4:=0, console.TabSizeQ5:=0, console.TabSizeQ6:=0
console.HeaderQ1:='s.q1', console.HeaderQ2:='s.q2', console.HeaderQ3:='s.q3', console.HeaderQ4:='s.q4', console.HeaderQ5:='s.q5', console.HeaderQ6:='s.q6'
console.AutoMerge := true
console.dateTimeFormat('dd.MMM.yy HH:mm')
console.FrameColor :=color.blue
console.MarkNewBar := false
console.MinWidth := 80
// dataLogx.ShowQ1:=true, dataLogx.ShowQ2:=false, dataLogx.ShowQ3:=false, dataLogx.ShowQ4:=false, dataLogx.ShowQ5:=false, dataLogx.ShowQ6:=false
demo.Status:=''
demo.IsConsole:=false
demo.clear()
demo.PageOnEveryBar := false
demo.MoveLogUp := true
demo.ColorText := false
demo.HighlightText := false
demo.ShowBarIndex := false
demo.ShowDateTime := false
demo.ShowLogLevels :=false
demo.ReplaceWithCodes:=false
demo.ShowHeader := true
demo.HeaderAtTop := true
demo.StatusBarAtBottom := true
demo.ShowStatusBar := true
demo.ShowMetaStatus := true
demo.ShowQ1:=true, demo.ShowQ2:=true, demo.ShowQ3:=true, demo.ShowQ4:=true, demo.ShowQ5:=true, demo.ShowQ6:=true
demo.TabSizeQ1:=0, demo.TabSizeQ2:=0, demo.TabSizeQ3:=0, demo.TabSizeQ4:=0, demo.TabSizeQ5:=0, demo.TabSizeQ6:=0
demo.HeaderQ1:='s.q1', demo.HeaderQ2:='s.q2', demo.HeaderQ3:='s.q3', demo.HeaderQ4:='s.q4', demo.HeaderQ5:='s.q5', demo.HeaderQ6:='s.q6'
demo.AutoMerge := true
demo.dateTimeFormat('dd.MMM.yy HH:mm')
demo.FrameColor :=color.yellow
demo.MarkNewBar := false
demo.MinWidth := 80
demo.StatusTooltip :='Attachment Testing'
console.StatusTooltip :='Attachment Testing'
cza+=1
if idza==1 or idza==60 or idza==73 or idza==85 or idza==96 or idza==170
cza:=0
eza=((cza-1)%__colors)+1
px_gold = str.tostring(request.security('TVC:GOLD',timeframe.period,close))+' = Gold'
px_ukoil= str.tostring(request.security('TVC:UKOIL',timeframe.period,close))+' = Brent Crude'
px_dow = str.tostring(request.security('TVC:DJI',timeframe.period,close))+' = Dow'
px_ftse = str.tostring(request.security('TVC:UKX',timeframe.period,close))+' = FTSE'
if idza==6
console.clear()
if (idza>=1 and idza<7) or (idza>10 and idza<=abarFinalTestDone)
gm1:=consoleBus.get(zc,prodcolmsg), gm2:=consoleBus.get(zc,prodcolm2), gm3:=consoleBus.get(zc,prodcolm3), gm4:=consoleBus.get(zc,prodcolm4), gm5:=consoleBus.get(zc,prodcolm5), gm6:=consoleBus.get(zc,prodcolm6),
gs:=consoleBus.get(zc,prodcolstatusC)
console.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog), console.Status:=gs
gm1:=logxBus.get(zx,prodcolm1), gm2:=logxBus.get(zx,prodcolm2), gm3:=logxBus.get(zx,prodcolm3), gm4:=logxBus.get(zx,prodcolm4), gm5:=logxBus.get(zx,prodcolm5), gm6:=logxBus.get(zx,prodcolm6),
gs:=logxBus.get(zx,prodcolstatusL)
demo.log(ezc,gm1,gm2,gm3,gm4,gm5,gm6, log=gm1!=o_skiplog), demo.Status:=gs
if (idza>=1 and idza<=abarFinalTestDone)
za+=1
zx+=1
zc+=1
switch idza
6 => demo.attach(console,'bottom'), demo.SeparatorColor:=c_cream
7 => console.page(0,'Inside attached console one can track, for instance, other markets?\n'+px_gold+'\n'+px_ukoil+'\n'+px_dow+'\n'+px_ftse), demo.log(eza,'1 of 4 .. Inside Logx tracking current ticker = '+syminfo.ticker,'Current price = <'+str.tostring(close)+'>')
8 => console.page(0,'Inside attached console one can track, for instance, other markets?\n'+px_ukoil+'\n'+px_dow+'\n'+px_ftse+'\n'+px_gold), demo.log(eza,'2 of 4 .. Inside Logx tracking current ticker = '+syminfo.ticker,'Current price = <'+str.tostring(close)+'>')
9 => console.page(0,'Inside attached console one can track, for instance, other markets?\n'+px_dow+'\n'+px_ftse+'\n'+px_gold+'\n'+px_ukoil), demo.log(eza,'3 of 4 .. Inside Logx tracking current ticker = '+syminfo.ticker,'Current price = <'+str.tostring(close)+'>')
10 => console.page(0,'Inside attached console one can track, for instance, other markets?\n'+px_ftse+'\n'+px_gold+'\n'+px_ukoil+'\n'+px_dow), demo.log(eza,'4 of 4 .. Inside Logx tracking current ticker = '+syminfo.ticker,'Current price = <'+str.tostring(close)+'>')
13 => demo.attach(console,'Left')
15 => console.StatusBarAtBottom:=false
16 => demo.attach(console,'Top')
19 => demo.attach(console,'Right')
22 => demo.StatusBarAtBottom:=false
23 => demo.attach(console,'anywhere')
26 => demo.detach(console)
28 => demo.StatusBarAtBottom:=true, console.StatusBarAtBottom:=true
console.show (position= L_bottom_center.getTablePosition(),hhalign=hhalign_uat, hvalign=hvalign_uat, hsize=hsize_uat, thalign=thalign_uat, tvalign=tvalign_uat, tsize=tsize_uat, show=showAttachedConsole)
//______ xx ______________________________ TESTING Attachment of Console to Logx
demo.show (position= pos_uat,hhalign=hhalign_uat, hvalign=hvalign_uat, hsize=hsize_uat, thalign=thalign_uat, tvalign=tvalign_uat, tsize=tsize_uat, show=(showLogx or showConsole or showAttachedConsole or consoleAttached), attach=consoleAttached?console:na)
demo.showColors(position=position.bottom_left,showColors=(idzx>=108 and idzx<=123) or (idzc>=108 and idzc<=123))
// logger.3 td4.3 td5.3
|
Trend Angle Candle Color | https://www.tradingview.com/script/Gl4Jco0X-Trend-Angle-Candle-Color/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 49 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Trend Angle Candle Color", overlay = true)
grad(src)=>
color out = switch 100 - int(src)
0 => color.new(#1500FF , 0)
1 => color.new(#1709F6 , 0)
2 => color.new(#1912ED , 0)
3 => color.new(#1B1AE5 , 0)
4 => color.new(#1D23DC , 0)
5 => color.new(#1F2CD3 , 0)
6 => color.new(#2135CA , 0)
7 => color.new(#233EC1 , 0)
8 => color.new(#2446B9 , 0)
9 => color.new(#264FB0 , 0)
10 => color.new(#2858A7 , 0)
11 => color.new(#2A619E , 0)
12 => color.new(#2C6A95 , 0)
13 => color.new(#2E728D , 0)
14 => color.new(#307B84 , 0)
15 => color.new(#32847B , 0)
16 => color.new(#348D72 , 0)
17 => color.new(#36956A , 0)
18 => color.new(#389E61 , 0)
19 => color.new(#3AA758 , 0)
20 => color.new(#3CB04F , 0)
21 => color.new(#3EB946 , 0)
22 => color.new(#3FC13E , 0)
23 => color.new(#41CA35 , 0)
24 => color.new(#43D32C , 0)
25 => color.new(#45DC23 , 0)
26 => color.new(#47E51A , 0)
27 => color.new(#49ED12 , 0)
28 => color.new(#4bf609 , 0)
29 => color.new(#58f600 , 0)
30 => color.new(#64f700 , 0)
31 => color.new(#6ff700 , 0)
32 => color.new(#78f700 , 0)
33 => color.new(#81f700 , 0)
34 => color.new(#89f800 , 0)
35 => color.new(#91f800 , 0)
36 => color.new(#99f800 , 0)
37 => color.new(#a0f800 , 0)
38 => color.new(#a7f800 , 0)
39 => color.new(#aef900 , 0)
40 => color.new(#b5f900 , 0)
41 => color.new(#bbf900 , 0)
42 => color.new(#c2f900 , 0)
43 => color.new(#c8f900 , 0)
44 => color.new(#cef900 , 0)
45 => color.new(#d4f900 , 0)
46 => color.new(#d9f900 , 0)
47 => color.new(#dff900 , 0)
48 => color.new(#e5f900 , 0)
49 => color.new(#eaf900 , 0)
50 => color.new(#eaf900 , 0)
51 => color.new(#ebf400 , 0)
52 => color.new(#ecee00 , 0)
53 => color.new(#ede900 , 0)
54 => color.new(#eee300 , 0)
55 => color.new(#efde00 , 0)
56 => color.new(#efd800 , 0)
57 => color.new(#efd300 , 0)
58 => color.new(#f0cd00 , 0)
59 => color.new(#f0c800 , 0)
60 => color.new(#f0c200 , 0)
61 => color.new(#f0bc00 , 0)
62 => color.new(#efb700 , 0)
63 => color.new(#efb100 , 0)
64 => color.new(#eeac00 , 0)
65 => color.new(#eea600 , 0)
66 => color.new(#eda100 , 0)
67 => color.new(#ec9b00 , 0)
68 => color.new(#eb9600 , 0)
69 => color.new(#ea9000 , 0)
70 => color.new(#e98b00 , 0)
71 => color.new(#e88500 , 0)
72 => color.new(#e68000 , 0)
73 => color.new(#e57a00 , 0)
74 => color.new(#e37500 , 0)
75 => color.new(#e16f00 , 0)
76 => color.new(#df6a00 , 0)
77 => color.new(#dd6400 , 0)
78 => color.new(#db5e00 , 0)
79 => color.new(#d95800 , 0)
80 => color.new(#d75300 , 0)
81 => color.new(#d44d00 , 0)
82 => color.new(#d24600 , 0)
83 => color.new(#cf4000 , 0)
84 => color.new(#cc3a00 , 0)
85 => color.new(#c93301 , 0)
86 => color.new(#c62c05 , 0)
87 => color.new(#c32408 , 0)
88 => color.new(#c01a0b , 0)
89 => color.new(#bd0e0e , 0)
90 => color.new(#F60000 , 0)
91 => color.new(#DF0505 , 0)
92 => color.new(#C90909 , 0)
93 => color.new(#B20E0E , 0)
94 => color.new(#9B1313 , 0)
95 => color.new(#851717 , 0)
96 => color.new(#6E1C1C , 0)
97 => color.new(#572121 , 0)
98 => color.new(#412525 , 0)
99 => color.new(#2A2A2A , 0)
100 => color.new(#1A1818 , 20)
=> color.white
length = input.int(8, "Length", 1)
scale = input.int(2, "Scale", 1)
smooth = input.float(1, "Smooting", 1)
factor = input.float(1, "Smoothing Factor", 0.125, 100, 0.125)
ema(source)=>
var float ema = 0.0
var int count = 0
count := nz(count[1]) + 1
ema := (1.0 - 2.0 / (count + 1.0)) * nz(ema[1]) + 2.0 / (count + 1.0) * source
ema
atan2(y, x) =>
var float angle = 0.0
if x > 0
angle := math.atan(y / x)
else
if x < 0 and y >= 0
angle := math.atan(y / x) + math.pi
else
if x < 0 and y < 0
angle := math.atan(y / x) - math.pi
else
if x == 0 and y > 0
angle := math.pi / 2
else
if x == 0 and y < 0
angle := -math.pi / 2
angle
degrees(float source) =>
source * 180 / math.pi
// Epanechnikov kernel function
epanechnikov_kernel(_src, _size, _h, _r) =>
_currentWeight = 0.0
_cumulativeWeight = 0.0
for i = 0 to _size
y = _src[i]
u = math.pow(i, 2) / (math.pow(_h, 2) * _r)
w = (u >= 1) ? 0 : (3. / 4) * (1 - math.pow(u, 2))
_currentWeight := _currentWeight + y * w
_cumulativeWeight := _cumulativeWeight + w
_currentWeight / _cumulativeWeight
atr = ema(ta.tr)
slope = (close - close[length]) / (atr/(length/scale) * length)
angle_rad = atan2(slope, 1)
degrees = (epanechnikov_kernel(degrees(angle_rad), length, smooth, factor) + 90) / 180 * 100
colour = grad(degrees)
barcolor(colour)
plotcandle(open, high, low, close, "Trend Candles", colour, colour, true, bordercolor = colour) |
T3 Oscillator | https://www.tradingview.com/script/L4wzVG0t-T3-Oscillator/ | Daniel_Ge | https://www.tradingview.com/u/Daniel_Ge/ | 30 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Daniel_Ge
//@version=5
indicator("T3 Oscillator", "T3O", overlay = false, timeframe = "")
// Input
src = input(close, "Source")
t3_length = input.int(50, "Length")
smooth_length = input.int(3, "Smoothing Length", minval = 1, tooltip = "1 = no smoothing")
volume_factor = input.float(0.618, "Volume Factor", step = 0.01, tooltip = "0.7 is the original value used by Tim Tillson. Other common values are 0.618 and 0.55")
// T3 MA Function
t3_ma(source, length) =>
ema_i1 = ta.ema(source, length)
ema_i2 = ta.ema(ema_i1, length)
ema_i3 = ta.ema(ema_i2, length)
ema_i4 = ta.ema(ema_i3, length)
ema_i5 = ta.ema(ema_i4, length)
ema_i6 = ta.ema(ema_i5, length)
const07 = volume_factor
var1 = -const07 * const07 * const07
var2 = 3 * const07 * const07 + 3 * const07 * const07 * const07
var3 = -6 * const07 * const07 - 3 * const07 - 3 * const07 * const07 * const07
var4 = 1 + 3 * const07 + const07 * const07 * const07 + 3 * const07 * const07
t3 = var1 * ema_i6 + var2 * ema_i5 + var3 * ema_i4 + var4 * ema_i3
t3
//
// Calc Oscillator and Smoothing
t3 = ta.sma(src - t3_ma(src, t3_length), smooth_length)
// Plots
hline(0, "Zero Line", linestyle = hline.style_dotted)
p0 = plot(0, editable = false, display = display.none) // placeholder for filling
p1 = plot(t3, "T3 Oscillator", color = color(#d1d4dc), linewidth = 2)
fill(p0, p1, color = t3 > 0 ? color.new(#0095bb, 70) : color.new(#b2b5be, 70), title = "Filling")
// Alerts
co = ta.crossover(t3, 0)
alertcondition(co, "T3O Cross over 0", "")
cu = ta.crossunder(t3, 0)
alertcondition(cu, "T3O Cross under 0") |
ICT Session Opening FVG / Silver Bullet [MK] | https://www.tradingview.com/script/WOFcFdAY-ICT-Session-Opening-FVG-Silver-Bullet-MK/ | malk1903 | https://www.tradingview.com/u/malk1903/ | 888 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © malk1903
//@version=5
indicator("Session Opening FVG / Silver Bullet [MK]", shorttitle="Opening FVG/Silver Bullet [MK]",overlay = true, max_lines_count = 500, max_boxes_count = 500)
//------------------------------------------------------------------------------
//Settings
timeZone = input.string("GMT-4", title="Time Zone", options=["GMT-10","GMT-9","GMT-8","GMT-7","GMT-6","GMT-5","GMT-4","GMT-3","GMT-2","GMT-1","GMT","GMT+1","GMT+2","GMT+3","GMT+4","GMT+5","GMT+6","GMT+7","GMT+8","GMT+9","GMT+10"], group="Timezone")
tf=input.timeframe(defval="Chart", title="Timeframe", options=["Chart", "1", "2", "3", "4", "5", "15"], tooltip="Timeframe used for FVG detection")
if tf == "Chart"
tf := ""
i_maxtf_og = input.int (5, "Max Timeframe", 1, 240, tooltip="Indicator will not work on chart timeframes above this value")
disp_og = timeframe.isintraday and timeframe.multiplier <= i_maxtf_og
t1H = input.int(16, title = 'Hour', inline="1", group="Extend Boxes")
t1m = input.int(00, title = 'Minute', inline="1", group="Extend Boxes")
ext_2last = input.bool(defval=false, title="Extend to Future Time", inline="1", group="Extend Boxes")
os_bx = input.int(3, title = 'Box Offset', minval=0, maxval=200, inline="1", group="Extend Boxes", tooltip="Extend box to right, this works if 'Extend to Future Time' is not selected")
//Session Periods.
Ldn_Kz_2 = input.session ('0200-0259:1234567', "LDN KZ 0200", inline='1', group="Sessions")
Ldn_Kz_3 = input.session ('0300-0359:1234567', "LDN KZ 0300", inline='2', group="Sessions")
Ldn_Kz_4 = input.session ('0400-0459:1234567', "LDN KZ 0400", inline='3', group="Sessions")
Dead_Kz_5 = input.session ('0500-0559:1234567', "Dead KZ 0500", inline='4', group="Sessions")
Dead_Kz_6 = input.session ('0600-0659:1234567', "Dead KZ 0600", inline='5', group="Sessions")
NY_Kz_7 = input.session ('0700-0829:1234567', "NY KZ 0700", inline='6', group="Sessions")
NY_Kz_830 = input.session ('0830-0929:1234567', "NY KZ 0830", inline='7', group="Sessions")
NY_Kz_930 = input.session ('0930-0959:1234567', "NY KZ 0930", inline='8', group="Sessions")
NY_Kz_10 = input.session ('1000-1059:1234567', "NY KZ 1000", inline='9', group="Sessions")
NY_Kz_13 = input.session ('1300-1359:1234567', "NY KZ 1300", inline='9b', group="Sessions")
NY_Kz_14 = input.session ('1400-1459:1234567', "NY KZ 1400", inline='10', group="Sessions")
NY_Kz_15 = input.session ('1500-1559:1234567', "NY KZ 1500", inline='10b', group="Sessions")
Extra_1 = input.session ('0100-0110:1234567', "Ex_1", inline='11', group="Sessions")
Ex_txt1 = input.string(defval="Extra 1", title="Text", inline='11', group="Sessions")
i_Ex1 = input.bool(defval=false, title="On/Off", inline='11', group="Sessions")
Extra_2 = input.session ('0115-0125:1234567', "Ex_12", inline='12', group="Sessions")
Ex_txt2 = input.string(defval="Extra 2", title="Text", inline='12', group="Sessions")
i_Ex2 = input.bool(defval=false, title="On/Off", inline='12', group="Sessions")
Extra_3 = input.session ('0130-0140:1234567', "Ex_3", inline='13', group="Sessions")
Ex_txt3 = input.string(defval="Extra 3", title="Text", inline='13', group="Sessions")
i_Ex3 = input.bool(defval=false, title="On/Off", inline='13', group="Sessions")
//Enable/Disable Session Periods
i_kx2 = input.bool(defval=false, title="On/Off", inline='1', group="Sessions")
i_kx3 = input.bool(defval=true, title="On/Off", inline='2', group="Sessions")
i_kx4 = input.bool(defval=false, title="On/Off", inline='3', group="Sessions")
i_kx5 = input.bool(defval=false, title="On/Off", inline='4', group="Sessions")
i_kx6 = input.bool(defval=false, title="On/Off", inline='5', group="Sessions")
i_kx7 = input.bool(defval=false, title="On/Off", inline='6', group="Sessions")
i_kx830 = input.bool(defval=true, title="On/Off", inline='7', group="Sessions")
i_kx930 = input.bool(defval=true, title="On/Off", inline='8', group="Sessions")
i_kx10 = input.bool(defval=true, title="On/Off", inline='9', group="Sessions")
i_kx13 = input.bool(defval=true, title="On/Off", inline='9b', group="Sessions")
i_kx14 = input.bool(defval=true, title="On/Off", inline='10', group="Sessions")
i_kx15 = input.bool(defval=true, title="On/Off", inline='10b', group="Sessions")
//Enable/Disable Session Periods
i_kx2_fo = input.bool(defval=false, title="First Only", inline='1', group="Sessions", tooltip="Shows only first FVG in session, The first FVG in a Seesion can be used as an aid to BIAS. eg, does the 0930 opening FVG get inverted as part of a judas swing")
i_kx3_fo = input.bool(defval=false, title="First Only", inline='2', group="Sessions")
i_kx4_fo = input.bool(defval=false, title="First Only", inline='3', group="Sessions")
i_kx5_fo = input.bool(defval=false, title="First Only", inline='4', group="Sessions")
i_kx6_fo = input.bool(defval=false, title="First Only", inline='5', group="Sessions")
i_kx7_fo = input.bool(defval=false, title="First Only", inline='6', group="Sessions")
i_kx830_fo = input.bool(defval=true, title="First Only", inline='7', group="Sessions")
i_kx930_fo = input.bool(defval=true, title="First Only", inline='8', group="Sessions")
i_kx10_fo = input.bool(defval=false, title="First only", inline='9', group="Sessions")
i_kx13_fo = input.bool(defval=true, title="First Only", inline='9b', group="Sessions")
i_kx14_fo = input.bool(defval=false, title="First Only", inline='10', group="Sessions")
i_kx15_fo = input.bool(defval=true, title="First Only", inline='10b', group="Sessions")
//Box Colors,Borders, Text Colors
fvgb_imb_c = input.color(defval=color.new(color.yellow,70),title="FVG Bull Box", inline="1", group="Colors + Labels")
fvgbr_imb_c = input.color(defval=color.new(color.blue,70),title="FVG Bear Box", inline="1", group="Colors + Labels")
mline = input.color(color.new(color.silver,50), 'Mid Line', inline="1", group="Colors + Labels")
txt_c = input.color(color.new(color.silver,0), 'Text', inline="1", group="Colors + Labels")
txt_on = input.bool(defval=true, title="Show Text", inline="2", group="Colors + Labels")
tf_on = input.bool(defval=true, title="Show Timeframe", tooltip="Shows timeframe chosen for FVG detection if it has been selected, If 'Chart' has been selected for FVG detection, then nothing will be displayed", inline="2", group="Colors + Labels")
fvgb_imb_cfo = input.color(defval=color.new(color.green,40),title="FVG Bull Box", inline="1", group="Colors First Only")
fvgbr_imb_cfo = input.color(defval=color.new(color.red,40),title="FVG Bear Box", inline="1", group="Colors First Only")
t1 = timestamp(timeZone, year, month, dayofmonth, t1H, t1m, 00)
txt_tf = tf == "5" ? "5m" : tf == "4" ? "4m" : tf == "3" ? "3m" : tf == "2" ? "2m" : tf == "1" ? "1m" : ""
//UDT's
type fvg
float top
float btm
bool mitigated
bool isnew
bool isbull
line lvl
box area
string txt
//Method for setting fair value gaps
method set_fvg(fvg id, offset, bg_c, l_c, txt)=>
avg = math.avg(id.top, id.btm)
// area = box.new(time[2], id.top, t1, id.btm, na, bgcolor = bg_c, text=txt_on and tf_on ? txt + " " + txt_tf : txt_on ? txt : tf_on ? txt_tf : na, text_color=txt_c, text_halign=text.align_right, text_size=size.normal, xloc = xloc.bar_time)
// avg_l = line.new(time[2] - offset, avg, t1, avg, color = l_c, style = line.style_dashed, xloc = xloc.bar_time)
area = box.new(time[1], id.top, ext_2last ? t1 : time + (os_bx * 1000000), id.btm, na, bgcolor = bg_c, text=txt_on and tf_on ? txt + " " + txt_tf : txt_on ? txt : tf_on ? txt_tf : na, text_color=txt_c, text_halign=text.align_right, text_size=size.normal, xloc = xloc.bar_time)
avg_l = line.new(time[1] - offset, avg, ext_2last ? t1 : time + (os_bx * 1000000), avg, color = l_c, style = line.style_dashed, xloc = xloc.bar_time)
id.lvl := avg_l
id.area := area
//Variables
var fvg sfvg = fvg.new(na, na, na, true, na)
var fvg sfvg2 = fvg.new(na, na, na, true, na)
var box area = na
// //mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
// // get higher timeframe price values
// _getHLvalues(_ticker,_tf,_high2,_high1,_high,_low2,_low1,_low,_close1,_open1) =>
// request.security(_ticker,tf,[_high2,_high1,_high,_low2,_low1,_low,_close1,_open1],lookahead = barmerge.lookahead_on)
// //request values using chosen TF
// [_high2,_high1,_high,_low2,_low1,_low,_close1,_open1] = _getHLvalues(syminfo.tickerid,tf,high[2],high[1],high,low[2],low[1],low,close[1],open[1])
// //mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
// Create non-repainting security function
rp_security(_symbol, tf, _src) =>
request.security(_symbol, tf, _src[barstate.isrealtime ? 1 : 0],barmerge.gaps_on,barmerge.lookahead_on)//added the lookahead bit
// Get HTF price data
_high2 = rp_security(syminfo.tickerid, tf, high[2])
_high = rp_security(syminfo.tickerid, tf, high)
_low2 = rp_security(syminfo.tickerid, tf, low[2])
_low = rp_security(syminfo.tickerid, tf, low)
_close = rp_security(syminfo.tickerid, tf, close)
_close1 = rp_security(syminfo.tickerid, tf, close[1])
_open1 = rp_security(syminfo.tickerid, tf, open[1])
//detect bull and bear FVGs AND
//ORIGINAL VERSION//bull_fvg = (_high2 < _low and _close > _open1 and barstate.isconfirmed) or (_low2 > _high and _close < _open1 and barstate.isconfirmed)//added the close > open so that logic waited for a close condition on newest candle
bull_fvg = (_high2 < _low) or (_low2 > _high)//added the close > open so that logic waited for a close condition on newest candle
is_bull = false
if _close1 > _open1
is_bull :=true
in_session(sess) =>
not na(time(timeframe.period, sess, timeZone))
txt = in_session(Ldn_Kz_2) ? "0200" : in_session(Ldn_Kz_3) ? "0300" : in_session(Ldn_Kz_4) ? "0400" : in_session(Dead_Kz_5) ? "0500" : in_session(Dead_Kz_6) ? "0600" : in_session(NY_Kz_7) ? "0700" : in_session(NY_Kz_830) ? "0830" : in_session(NY_Kz_930) ? "0930" : in_session(NY_Kz_10) ? "1000" : in_session(NY_Kz_13) ? "1300" : in_session(NY_Kz_14) ? "1400" : in_session(NY_Kz_15) ? "1500" : in_session(Extra_1) ? Ex_txt1 : in_session(Extra_2) ? Ex_txt2 : in_session(Extra_3) ? Ex_txt3 : na
//New session bullish fvg
if bull_fvg and sfvg.isnew
sfvg := fvg.new(is_bull ? _low : _low2, is_bull ? _high2 : _high, false, false, true)
sfvg.set_fvg(2, is_bull ? fvgb_imb_cfo : fvgbr_imb_cfo, mline, txt)
IsSessionStart(sessionTime, sessionTimeZone=syminfo.timezone) =>
inSess = not na(time(timeframe.period, sessionTime, sessionTimeZone))
inSess and not inSess[1]
IsLastBarSession(sessionTime, sessionTimeZone=syminfo.timezone) =>
var int lastBarHour = na
var int lastBarMinute = na
var int lastBarSecond = na
inSess = not na(time(timeframe.period, sessionTime, sessionTimeZone))
if not inSess and inSess[1]
lastBarHour := hour[1]
lastBarMinute := minute[1]
lastBarSecond := second[1]
hour == lastBarHour and minute == lastBarMinute and second == lastBarSecond
//function for findng first FVG within sesion
firstbox(kz, i_kx)=>
seshstart = IsSessionStart(kz,timeZone)
seshend = IsLastBarSession(kz, timeZone)
if seshstart and i_kx and disp_og
sfvg.isnew := true
if seshend
sfvg.isnew := false
//send to first FVG function
if i_kx2_fo and disp_og
firstbox(Ldn_Kz_2, i_kx2)
if i_kx3_fo and disp_og
firstbox(Ldn_Kz_3, i_kx3)
if i_kx4_fo and disp_og
firstbox(Ldn_Kz_4, i_kx4)
if i_kx5_fo and disp_og
firstbox(Dead_Kz_5, i_kx5)
if i_kx6_fo and disp_og
firstbox(Dead_Kz_6, i_kx6)
if i_kx7_fo and disp_og
firstbox(NY_Kz_7, i_kx7)
if i_kx830_fo and disp_og
firstbox(NY_Kz_830, i_kx830)
if i_kx930_fo and disp_og
firstbox(NY_Kz_930, i_kx930)
if i_kx10_fo and disp_og
firstbox(NY_Kz_10, i_kx10)
if i_kx13_fo and disp_og
firstbox(NY_Kz_13, i_kx13)
if i_kx14_fo and disp_og
firstbox(NY_Kz_14, i_kx14)
if i_kx15_fo and disp_og
firstbox(NY_Kz_15, i_kx15)
//function for findng all FVG within session
seshbox(kz, i_kx, txt,tf)=>
sesh = in_session(kz)
var box bull_fvg_bx = na
var boxes = array.new_box()
avg = (math.max(_low, _low2) + math.min(_high, _high2)) / 2
if bull_fvg and sesh and i_kx
bull_fvg_bx := box.new(time[1], is_bull ? _low : _low2, ext_2last ? t1 : time + (os_bx * 1000000), is_bull ? _high2 : _high,bgcolor = is_bull ? fvgb_imb_c : fvgbr_imb_c, border_color = color.new(color.black,100), xloc=xloc.bar_time, text_color=txt_c, text=txt_on and tf_on ? txt + " " + txt_tf : txt_on ? txt : tf_on ? txt_tf : na, text_size=size.normal, text_halign=text.align_right)
avg_l = line.new(time[1], avg, ext_2last ? t1 : time + (os_bx * 1000000), avg, color = mline, style = line.style_dashed, xloc = xloc.bar_time)
array.push(boxes, bull_fvg_bx)
//send to all FVG function
if not i_kx2_fo and disp_og
seshbox(Ldn_Kz_2, i_kx2, "0200", tf)
if not i_kx3_fo and disp_og
seshbox(Ldn_Kz_3, i_kx3, "0300", tf)
if not i_kx4_fo and disp_og
seshbox(Ldn_Kz_4, i_kx4, "0400", tf)
if not i_kx5_fo and disp_og
seshbox(Dead_Kz_5, i_kx5, "0500", tf)
if not i_kx6_fo and disp_og
seshbox(Dead_Kz_6, i_kx6, "0600", tf)
if not i_kx7_fo and disp_og
seshbox(NY_Kz_7, i_kx7, "0700", tf)
if not i_kx830_fo and disp_og
seshbox(NY_Kz_830, i_kx830, "0830", tf)
if not i_kx930_fo and disp_og
seshbox(NY_Kz_930, i_kx930, "0930", tf)
if not i_kx10_fo and disp_og
seshbox(NY_Kz_10, i_kx10, "1000", tf)
if not i_kx13_fo and disp_og
seshbox(NY_Kz_13, i_kx13, "1300", tf)
if not i_kx14_fo and disp_og
seshbox(NY_Kz_14, i_kx14, "1400", tf)
if not i_kx15_fo and disp_og
seshbox(NY_Kz_15, i_kx15, "1500", tf)
if i_Ex1 and disp_og
seshbox(Extra_1, i_Ex1, Ex_txt1, tf)
if i_Ex2 and disp_og
seshbox(Extra_2, i_Ex2, Ex_txt2, tf)
if i_Ex3 and disp_og
seshbox(Extra_3, i_Ex3, Ex_txt3, tf) |
[5-2-2023] MNQ CALC | https://www.tradingview.com/script/wGnCmwNU-5-2-2023-MNQ-CALC/ | Perry_Trades | https://www.tradingview.com/u/Perry_Trades/ | 4 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © perrysrich
//@version=5
indicator("MNQ Calc", overlay=true)
risking = input.int(title="Dollar Risk", defval = 100, minval = 100)
location_table(type) =>
switch type
"Top Right" => position.top_right
"Top Left" => position.top_left
"Bottom Right" => position.bottom_right
"Bottom Left" => position.bottom_left
position = input.string(title="Table Position?", defval = "Bottom Right", options = ["Bottom Right", "Top Right", "Top Left", "Bottom Left"])
final_location = location_table(position)
prevCandleSize = (math.abs(high[1] - low[1]))
stopLoss = input.float(title="Price of Stop Loss:", defval = 0, minval = 0)
contractsNeeded = math.round(risking / ((math.abs(close[1] - stopLoss)) * 2))
var mnqTable = table.new(position = final_location, columns = 4, rows = 4, bgcolor = color.white, border_color = color.rgb(0, 0, 0), border_width = 4)
if barstate.islast
table.cell(table_id = mnqTable, column = 0, row = 0, text="Prev Candle Size: " + str.tostring(prevCandleSize) + " Pts")
table.cell(table_id = mnqTable, column = 0, row = 1, text="Reccommended Contracts: " + str.tostring(contractsNeeded))
table.cell(table_id = mnqTable, column = 1, row = 0, text="Current Risk: $" + str.tostring(risking))
table.cell(table_id = mnqTable, column = 1, row = 1, text="Stop Loss: " + str.tostring(stopLoss))
// if account is risking this amount, stop loss should be at what yloc.price
|
Top12/Bottom88 Weighted Ratio | https://www.tradingview.com/script/42uBbSOj-Top12-Bottom88-Weighted-Ratio/ | MarlosClock | https://www.tradingview.com/u/MarlosClock/ | 8 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © MarlosClock
// first pine script, Top 12 QQQ Tick
//@version=5
indicator('Top12/Bottom88 Weighted Ratio ', shorttitle='Top12/Bot88', overlay=false)
FBclose = request.security('FB', '60', close[0])
AAPLclose = request.security('AAPL', '60', close[0])
AMZNclose = request.security('AMZN', '60', close[0])
NFLXclose = request.security('NFLX', '60', close[0])
GOOGclose = request.security('GOOG', '60', close[0])
GOOGLclose = request.security('GOOGL', '60', close[0])
MSFTclose = request.security('MSFT', '60', close[0])
TSLAclose = request.security('TSLA', '60', close[0])
NVDAclose = request.security('NVDA', '60', close[0])
ADBEclose = request.security('ADBE', '60', close[0])
AVGOclose = request.security('AVGO', '60', close[0])
COSTclose = request.security('COST', '60', close[0])
CSCOclose = request.security('CSCO', '60', close[0])
PEPclose = request.security('PEP', '60', close[0])
//https://ycharts.com/companies/QQQ/holdings
//weightings are multiplied by the percentage currently. May need to be updated periodically
FBw = 3.67 * FBclose
AAPLw = 12.24 * AAPLclose
AMZNw = 6.26 * AMZNclose
NFLXw = 1.16 * NFLXclose
GOOGw = 3.78 * GOOGclose
GOOGLw = 3.75 * GOOGLclose
MSFTw = 12.58* MSFTclose
TSLAw = 3.57 * TSLAclose
NVDAw = 5.00 * NVDAclose
ADBEw = 1.69 * ADBEclose
PEPw = 1.94 * PEPclose
AVGOw = 2.05 * AVGOclose
COSTw = 1.72 * COSTclose
CSCOw = 1.64 * CSCOclose
//56% of QQQ total
//TotW = FBw + AAPLw + AMZNw + NFLXw + GOOGw + GOOGLw + MSFTw
TotW12 = FBw + AAPLw + AMZNw + NFLXw + GOOGw + GOOGLw + MSFTw + TSLAw + NVDAw + ADBEw + AVGOw + CSCOw + COSTw + PEPw
src = TotW12
Bottom_88 = request.security('NDX', '60', close[0])
Bottom_88w = ((Bottom_88*88)-TotW12)/100
src2 = src/Bottom_88w
// Plot colors for histogram
col_grow_above = input(color.rgb(73, 222, 207, 20), "Above Grow", group="Histogram", inline="Above")
col_fall_above = input(color.rgb(207, 64, 164, 11), "Fall", group="Histogram", inline="Above")
col_grow_below = input(color.rgb(244, 79, 206, 13), "Below Grow", group="Histogram", inline="Below")
col_fall_below = input(color.rgb(255, 82, 82, 9), "Fall", group="Histogram", inline="Below")
col_grow_abovet= input(color.rgb(72, 250, 232, 10), "Above Grow", group="Histogram", inline="Above")
col_fall_abovet= input(color.rgb(232, 71, 170, 11), "Fall", group="Histogram", inline="Above")
col_grow_belowt= input(color.rgb(227, 73, 73, 5), "Below Grow", group="Histogram", inline="Below")
col_fall_belowt= input(color.rgb(255, 82, 171, 10), "Fall", group="Histogram", inline="Below")
//plot(src, title="Top12 Weighted Index", color=color.from_gradient(src,-40,40,color.fuchsia,color.teal))
plot(src2, title="Top12/Bot88", color=(src2>=0 ? (src2[1] < src2 ? col_grow_abovet : col_fall_abovet) : (src2[1] < src2 ? col_grow_belowt : col_fall_belowt)), style=plot.style_area)
|
Financial Radar Chart by zdmre | https://www.tradingview.com/script/8dGBPyTy-Financial-Radar-Chart-by-zdmre/ | zdmre | https://www.tradingview.com/u/zdmre/ | 55 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © zdmre
//@version=5
indicator('Financial Radar Chart by zdmre', overlay=false, max_lines_count=500, max_labels_count=500)
//inputs
period = input.string('FY', 'Period', options=['FQ', 'FY'], tooltip='FQ: Quarter\nFY: Annual')
sh_plot = input.bool(true,title="Show Plot&Tag")
radius = input.int(100, "Radius", group="Style")
offset = input.int(20, "Offset", group="Style")
//datas
de = request.financial(syminfo.tickerid,'TOTAL_DEBT', period) / request.financial(syminfo.tickerid,'TOTAL_EQUITY', period)
roic = request.financial(syminfo.tickerid,'RETURN_ON_INVESTED_CAPITAL', period)
evtoebitda = request.financial(syminfo.tickerid,'ENTERPRISE_VALUE_EBITDA', period)
dyield = request.financial(syminfo.tickerid,'DIVIDENDS_YIELD', period)
roe = request.financial(syminfo.tickerid,'RETURN_ON_EQUITY', period)
opmar = request.financial(syminfo.tickerid, 'OPERATING_MARGIN', period)
TSO = request.financial(syminfo.tickerid, "TOTAL_SHARES_OUTSTANDING", period)
FCF= request.financial(syminfo.tickerid, "FREE_CASH_FLOW", period)
MarketCap = TSO * close
pfcf = MarketCap / FCF
rg = request.financial(syminfo.tickerid, "REVENUE_ONE_YEAR_GROWTH", "FY")
//calculations
de_val = de < 0 ? 0 : de < 0.1 ? 1 : de < 0.2 ? 0.9 : de < 0.3 ? 0.8 : de < 0.4 ? 0.7 : de < 0.5 ? 0.6 : de < 0.6 ? 0.5 : de < 0.7 ? 0.4 : de < 0.8 ? 0.3 : de < 0.9 ? 0.2 : de < 1 ? 0.1 : 0
roic_val = roic < 0 ? 0 : roic > 50 ? 1 : roic > 40 ? 0.9 : roic > 30 ? 0.8 : roic > 20 ? 0.7 : roic > 10 ? 0.5 : roic > 5 ? 0.2 : 0
evtoebitda_val = evtoebitda < 0 ? 0 : evtoebitda < 3 ? 1 : evtoebitda < 5 ? 0.8 : evtoebitda < 7 ? 0.7 : evtoebitda < 8 ? 0.6 : evtoebitda < 10 ? 0.4 : evtoebitda < 12 ? 0.2 : 0
dyield_val = dyield > 0.5 ? 1 : dyield > 0.3 ? 0.9 : dyield > 0.2 ? 0.8 : dyield > 0.1 ? 0.7 : dyield > 0 ? 0.5 : 0
roe_val = roe < 0 ? 0 : roe > 50 ? 1 : roe > 40 ? 0.9 : roe > 30 ? 0.8 : roe > 20 ? 0.7 : roe > 10 ? 0.5 : roe > 5 ? 0.2 : 0
opmar_val = opmar < 0 ? 0 : opmar > 50 ? 1 : opmar > 30 ? 0.9 : opmar > 20 ? 0.8 : opmar > 15 ? 0.6 : opmar > 10 ? 0.4 : opmar > 0 ? 0.2 : 0
pfcf_val = pfcf < 0 ? 0 : pfcf < 5 ? 1 : pfcf < 7 ? 0.9 : pfcf < 10 ? 0.8 : pfcf < 16 ? 0.6 : pfcf < 18 ? 0.5 : pfcf < 20 ? 0.4 : pfcf < 22 ? 0.3 : pfcf < 30 ? 0.2 : pfcf < 40 ? 0.15 : pfcf < 50 ? 0.1 : pfcf < 60 ? 0.05 : 0
rg_val = rg > 0.2 ? 1: rg > 0.16 ? 0.9 : rg > 0.14 ? 0.8 : rg > 0.12 ? 0.7 : rg > 0.1 ? 0.5 : rg > 0.07 ? 0.4 : rg > 0.04 ? 0.3 : rg > 0.02 ? 0.2 : rg > 0 ? 0.1 : 0
//plots
plot(sh_plot ? de_val : na, title="Debt-Paying ability", color=color.yellow, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? roic_val : na, title="ROIC", color=color.aqua, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? evtoebitda_val : na, title="EV/EBITDA", color=color.purple, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? dyield_val : na, title="Dividend", color=color.green, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? roe_val : na, title="ROE", color=color.red, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? opmar_val : na, title="Operating ability", color=color.orange, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? pfcf_val : na, title="Free Cash ability", color=color.blue, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
plot(sh_plot ? rg_val : na, title="One Year Growth ability", color=color.navy, style=plot.style_stepline_diamond, linewidth=2, display=display.pane)
//labels
label de_lbl = sh_plot ? label.new(bar_index+1, de_val, "Debt:"+str.tostring( de_val*100), color=color.yellow, textcolor=color.black, size = size.small, style=label.style_label_left) : na, label.delete(de_lbl[1])
label roic_lbl = sh_plot ? label.new(bar_index+1, roic_val, "ROIC:"+str.tostring( roic_val*100), color=color.aqua, textcolor=color.black, size = size.small, style=label.style_label_left) : na ,label.delete(roic_lbl[1])
label evtoebitda_lbl = sh_plot ? label.new(bar_index+1, evtoebitda_val, "EV/Ebitda:"+str.tostring( evtoebitda_val*100), color=color.purple, textcolor=color.white, size = size.small, style=label.style_label_left) : na, label.delete(evtoebitda_lbl[1])
label dyield_lbl = sh_plot ? label.new(bar_index+1, dyield_val, "Dividend:"+str.tostring( dyield_val*100), color=color.green, textcolor=color.black, size = size.small, style=label.style_label_left) : na, label.delete(dyield_lbl[1])
label roe_lbl = sh_plot ? label.new(bar_index+1, roe_val, "ROE:"+str.tostring( roe_val*100), color=color.red, textcolor=color.black, size = size.small, style=label.style_label_left) : na, label.delete(roe_lbl[1])
label opmar_lbl = sh_plot ? label.new(bar_index+1, opmar_val, "Operating:"+str.tostring( opmar_val*100), color=color.orange, textcolor=color.black, size = size.small, style=label.style_label_left) : na, label.delete(opmar_lbl[1])
label pfcf_lbl = sh_plot ? label.new(bar_index+1, pfcf_val, "Cash:"+str.tostring(pfcf_val*100), color=color.blue, textcolor=color.black, size = size.small, style=label.style_label_left) : na, label.delete(pfcf_lbl[1])
label rg_lbl = sh_plot ? label.new(bar_index+1, rg_val, "Growth:"+str.tostring(rg_val*100), color=color.navy, textcolor=color.white, size = size.small, style=label.style_label_left) : na, label.delete(rg_lbl[1])
//arrays
var categories = array.new_string(0)
if barstate.isfirst
array.push(categories, 'DEBT PAYING Ability')
array.push(categories, 'EV/EBITDA')
array.push(categories, 'DIVIDEND')
array.push(categories, 'ROE')
array.push(categories, 'ROIC')
array.push(categories, 'OPERATING Ability')
array.push(categories, 'FREE CASH Ability')
array.push(categories, 'GROWTH Ability')
values = array.new_float(0)
if barstate.islast
array.push(values, de_val)
array.push(values, evtoebitda_val)
array.push(values, dyield_val)
array.push(values, roe_val)
array.push(values, roic_val)
array.push(values, opmar_val)
array.push(values, pfcf_val)
array.push(values, rg_val)
array.push(values, array.get(values, 0))
dt = math.round(time - time[1])
rdr = math.pi * 2 / array.size(categories)
var border = array.new_line(0)
var d_lines0 = array.new_line(0)
var d_linesa = array.new_line(0)
var d_linesb = array.new_line(0)
var d_linesc = array.new_line(0)
var d_linesd = array.new_line(0)
var value_lines = array.new_line(0)
var name_labels = array.new_label(0)
if barstate.isfirst
for i = 0 to array.size(categories)-1 by 1
array.push(border, line.new(na, na, na, na))
array.push(d_lines0, line.new(na, na, na, na))
array.push(d_linesa, line.new(na, na, na, na))
array.push(d_linesb, line.new(na, na, na, na))
array.push(d_linesc, line.new(na, na, na, na))
array.push(d_linesd, line.new(na, na, na, na))
array.push(value_lines, line.new(na, na, na, na))
array.push(name_labels, label.new(na, na, na))
//get coordinates
get_cord(x, y, z) =>
y1 = math.sin(rdr * x) * y
y2 = math.sin(rdr * (x + 1)) * z
x1 = time + dt * offset + dt * math.round((.5 * math.cos(rdr * x) * y + .5) * radius)
x2 = time + dt * offset + dt * math.round((.5 * math.cos(rdr * (x + 1)) * z + .5) * radius)
[x1, y1, x2, y2]
//draw lines
d_line(dl, i, x1_l, x2_l, y1_l, y2_l, wd, ls, color) =>
x_line = array.get(dl, i)
line.set_xloc(x_line, x1_l, x2_l, xloc=xloc.bar_time)
line.set_y1(x_line, y1_l)
line.set_y2(x_line, y2_l)
line.set_style(x_line, ls)
line.set_color(x_line, color)
line.set_width(x_line, wd)
if barstate.islast
for i = 0 to array.size(categories)-1 by 1
//get arrays
val_0 = array.get(values, i)
val_1 = array.get(values, i + 1)
z_line = array.get(d_lines0, i)
value_line = array.get(value_lines, i)
//lines
[x1_z, y1_z, x2_z, y2_z] = get_cord(i, 0, 0)
[x1, y1, x2, y2] = get_cord(i, 1, 1)
[x1_a, y1_a, x2_a, y2_a] = get_cord(i, .2, .2)
[x1_b, y1_b, x2_b, y2_b] = get_cord(i, .4, .4)
[x1_c, y1_c, x2_c, y2_c] = get_cord(i, .6, .6)
[x1_d, y1_d, x2_d, y2_d] = get_cord(i, .8, .8)
[x1_val, y1_val, x2_val, y2_val] = get_cord(i, val_0, val_1)
d_line(d_lines0, i, x1_z, x2_z, y1_z, y2_z, 1, line.style_dotted, color.gray)
d_line(d_linesa, i, x1_a, x2_a, y1_a, y2_a, 1, line.style_dotted, color.gray)
d_line(d_linesb, i, x1_b, x2_b, y1_b, y2_b, 1, line.style_dotted, color.gray)
d_line(d_linesc, i, x1_c, x2_c, y1_c, y2_c, 1, line.style_dotted, color.gray)
d_line(d_linesd, i, x1_d, x2_d, y1_d, y2_d, 1, line.style_dotted, color.gray)
d_line(border, i, x1, x2, y1, y2, 2, line.style_solid, color.gray)
d_line(value_lines, i , x1_val, x2_val, y1_val, y2_val, 1, line.style_solid, color.green)
//fillcolor
linefill.new(value_line, z_line, color.new(color.green,50))
//labels
d_x1 = time + dt * offset + dt * math.round(radius / 2)
label_loc = y1 == 1 ? label.style_label_down : y1 == -1 ? label.style_label_up : x1 > d_x1 ? label.style_label_left : label.style_label_right
osc_name = array.get(categories, i)
name_label = array.get(name_labels, i)
label.set_xloc(name_label, x1, xloc=xloc.bar_time)
label.set_y(name_label, y1)
label.set_text(name_label, osc_name)
label.set_textcolor(name_label, color.gray)
label.set_color(name_label, #ffffff10)
label.set_style(name_label, label_loc) |
No Code Signals | https://www.tradingview.com/script/LdeAtyjj-No-Code-Signals/ | SamRecio | https://www.tradingview.com/u/SamRecio/ | 66 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © SamRecio
//@version=5
indicator("No Code Signals",shorttitle = "[NCS]", overlay = true, max_bars_back = 5000, max_labels_count = 500)
src1 = input.source(open, title = "Indicator 1", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "1")
src2 = input.source(high, title = "Indicator 2 ", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "1")
src3 = input.source(low, title = "Indicator 3", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "2")
src4 = input.source(close, title = "Indicator 4 ", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "2")
src5 = input.source(hl2, title = "Indicator 5", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "3")
src6 = input.source(open, title = "Indicator 6 ", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "3")
src7 = input.source(high, title = "Indicator 7", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "4")
src8 = input.source(low, title = "Indicator 8 ", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "4")
src9 = input.source(close, title = "Indicator 9", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "5")
src0 = input.source(hl2, title = "Indicator 10", group = "🔷 🔹 IMPORTS 🔹 🔷", inline = "5")
srcid(_src,_lvl) =>
_src == "high"? high:
_src == "low"? low :
_src == "open"? open:
_src == "close"? close:
_src == "hl2"? hl2:
_src == "hlc3"? hlc3:
_src == "ohlc4"? ohlc4:
_src == "hlcc4"? hlcc4:
_src == "Indi_1"?src1:
_src == "Indi_2"?src2:
_src == "Indi_3"?src3:
_src == "Indi_4"?src4:
_src == "Indi_5"?src5:
_src == "Indi_6"?src6:
_src == "Indi_7"?src7:
_src == "Indi_8"?src8:
_src == "Indi_9"?src9:
_src == "Indi_10"?src0:
_src == "Level"?_lvl:
na
signal(v1, _type, v2) =>
_type == ">" ? v1 > v2 :
_type == ">=" ? v1 >= v2 :
_type == "<" ? v1 < v2 :
_type == "<=" ? v1 <= v2 :
_type == "==" ? v1 == v2 :
_type == "CrossOver" ? v1 > v2 and v1[1] <= v2[1] :
_type == "CrossUnder" ? v1 < v2 and v1[1] >= v2[1]:
na
////////////////////////////////
//User Defined Signal Settings//
////////////////////////////////
//Signal 1//
signal1_dir = input.string("Long", options = ["Long","Short","Disabled"], title = "Direction", group = "🔶 Signal 1 🔶", inline = "0")
signal1_src1 = input.string("Indi_1", options =["Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "Signal ➡", group = "🔶 Signal 1 🔶", inline = "1")
signal1_func = input.string("CrossOver", options =[">","<","==",">=","<=","CrossOver", "CrossUnder"], title="", group = "🔶 Signal 1 🔶", inline = "1")
signal1_src2 = input.string("Level", options =["Level","Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "", group = "🔶 Signal 1 🔶", inline = "1")
signal1_lvl = input.float(0.0, title = " Level", group = "🔶 Signal 1 🔶", inline = "3")
signal1_fire = signal(srcid(signal1_src1,0),signal1_func,srcid(signal1_src2,signal1_lvl)) and (signal1_dir != "Disabled")
signal1_long = signal1_fire and signal1_dir == "Long"
signal1_short = signal1_fire and signal1_dir == "Short"
alertcondition(signal1_fire, title = "Signal 1")
//Signal 2//
signal2_dir = input.string("Short", options = ["Long","Short","Disabled"], title = "Direction", group = "🔶 Signal 2 🔶", inline = "0")
signal2_src1 = input.string("Indi_1", options =["Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "Signal ➡", group = "🔶 Signal 2 🔶", inline = "1")
signal2_func = input.string("CrossUnder", options =[">","<","==",">=","<=","CrossOver", "CrossUnder"], title="", group = "🔶 Signal 2 🔶", inline = "1")
signal2_src2 = input.string("Level", options =["Level","Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "", group = "🔶 Signal 2 🔶", inline = "1")
signal2_lvl = input.float(0.0, title = " Level", group = "🔶 Signal 2 🔶", inline = "3")
signal2_fire = signal(srcid(signal2_src1,0),signal2_func,srcid(signal2_src2,signal2_lvl)) and (signal2_dir != "Disabled")
signal2_long = signal2_fire and signal2_dir == "Long"
signal2_short = signal2_fire and signal2_dir == "Short"
alertcondition(signal2_fire, title = "Signal 2")
//Signal 3//
signal3_dir = input.string("Disabled", options = ["Long","Short","Disabled"], title = "Direction", group = "🔶 Signal 3 🔶", inline = "0")
signal3_src1 = input.string("Indi_5", options =["Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "Signal ➡", group = "🔶 Signal 3 🔶", inline = "1")
signal3_func = input.string("CrossOver", options =[">","<","==",">=","<=","CrossOver", "CrossUnder"], title="", group = "🔶 Signal 3 🔶", inline = "1")
signal3_src2 = input.string("Indi_6", options =["Level","Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "", group = "🔶 Signal 3 🔶", inline = "1")
signal3_lvl = input.float(0.0, title = " Level", group = "🔶 Signal 3 🔶", inline = "3")
signal3_fire = signal(srcid(signal3_src1,0),signal3_func,srcid(signal3_src2,signal3_lvl)) and (signal3_dir != "Disabled")
signal3_long = signal3_fire and signal3_dir == "Long"
signal3_short = signal3_fire and signal3_dir == "Short"
alertcondition(signal3_fire, title = "Signal 3")
//Signal 4//
signal4_dir = input.string("Disabled", options = ["Long","Short","Disabled"], title = "Direction", group = "🔶 Signal 4 🔶", inline = "0")
signal4_src1 = input.string("Indi_7", options =["Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "Signal ➡", group = "🔶 Signal 4 🔶", inline = "1")
signal4_func = input.string("CrossUnder", options =[">","<","==",">=","<=","CrossOver", "CrossUnder"], title="", group = "🔶 Signal 4 🔶", inline = "1")
signal4_src2 = input.string("Indi_8", options =["Level","Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "", group = "🔶 Signal 4 🔶", inline = "1")
signal4_lvl = input.float(0.0, title = " Level", group = "🔶 Signal 4 🔶", inline = "3")
signal4_fire = signal(srcid(signal4_src1,0),signal4_func,srcid(signal4_src2,signal4_lvl)) and (signal4_dir != "Disabled")
signal4_long = signal4_fire and signal4_dir == "Long"
signal4_short = signal4_fire and signal4_dir == "Short"
alertcondition(signal4_fire, title = "Signal 4")
//Signal 5//
signal5_dir = input.string("Disabled", options = ["Long","Short","Disabled"], title = "Direction", group = "🔶 Signal 5 🔶", inline = "0")
signal5_src1 = input.string("Indi_9", options =["Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "Signal ➡", group = "🔶 Signal 5 🔶", inline = "1")
signal5_func = input.string("CrossOver", options =[">","<","==",">=","<=","CrossOver", "CrossUnder"], title="", group = "🔶 Signal 5 🔶", inline = "1")
signal5_src2 = input.string("Indi_10", options =["Level","Indi_1","Indi_2","Indi_3","Indi_4","Indi_5","Indi_6","Indi_7","Indi_8","Indi_9","Indi_10","open","high","low","close","hl2","hlc3","ohlc4","hlcc4"], title = "", group = "🔶 Signal 5 🔶", inline = "1")
signal5_lvl = input.float(0.0, title = " Level", group = "🔶 Signal 5 🔶", inline = "3")
signal5_fire = signal(srcid(signal5_src1,0),signal5_func,srcid(signal5_src2,signal5_lvl)) and (signal5_dir != "Disabled")
signal5_long = signal5_fire and signal5_dir == "Long"
signal5_short = signal5_fire and signal5_dir == "Short"
alertcondition(signal5_fire, title = "Signal 5")
/////////////////////
//Signal Automation//
/////////////////////
color1 = input.color(color.lime, title = "Long Color", group = "Signal Settings", inline = "1")
color2 = input.color(color.red, title = "Short Color", group = "Signal Settings", inline = "1")
sz = input.string("tiny", title = "Signal Size", options = ["auto","tiny","small","normal","large","huge"], group = "Signal Settings", inline = "2")
txt_color = input.color(color.rgb(0,0,0,100), title = "Text Color", group = "Signal Settings", inline = "2")
fire_long = signal1_long or signal2_long or signal3_long or signal4_long or signal5_long
fire_short = signal1_short or signal2_short or signal3_short or signal4_short or signal5_short
disp_signal(_signal,_dir,_name) =>
if _signal and _dir == "Long"
label.new(bar_index,high, yloc = yloc.abovebar, style = label.style_triangleup, text = _name, color = color1, size = sz, textcolor = txt_color)
if _signal and _dir == "Short"
label.new(bar_index,low, yloc = yloc.belowbar, style = label.style_triangledown, text = _name, color = color2, size = sz, textcolor = txt_color)
disp_signal(signal1_fire,signal1_dir,"Signal 1")
disp_signal(signal2_fire,signal2_dir,"Signal 2")
disp_signal(signal3_fire,signal3_dir,"Signal 3")
disp_signal(signal4_fire,signal4_dir,"Signal 4")
disp_signal(signal5_fire,signal5_dir,"Signal 5") |
Active Addresses | https://www.tradingview.com/script/mk1DWVtd-Active-Addresses/ | VanHe1sing | https://www.tradingview.com/u/VanHe1sing/ | 59 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © VanHelsing666
//@version=5
indicator("Active Addresses", shorttitle = "AASI")
active_adds = request.security("BTC_ACTIVEADDRESSES", "", close)
changes_price = (close - close[28])/close
changes_adres = (active_adds - active_adds[28])/active_adds
highest = ta.ema(ta.highest(changes_adres, 20), 5)
lowest = ta.ema(ta.lowest(changes_adres, 20), 5)
plot(highest, color = color.rgb(255, 82, 82, 50), style = plot.style_circles)
plot(lowest, color = color.rgb(76, 175, 79, 50), style = plot.style_circles)
plot(changes_price, color = color.orange, linewidth = 2)
plot(changes_adres, color = color.rgb(120, 123, 134, 31))
tbl = table.new(position.middle_right, 10, 10)
table.cell(tbl, 0, 0, text = "28 Day Price Change (%)", text_color = color.gray)
table.cell(tbl, 1, 0, bgcolor = color.orange)
table.cell(tbl, 0, 1, text = "28 Day Active Addresses Change (%)", text_color = color.gray)
table.cell(tbl, 1, 1, bgcolor = color.gray)
|
ADR/AWR/AMR Average Daily+Weekly+Monthly Range[Traders Reality] | https://www.tradingview.com/script/LMuUYB0P-ADR-AWR-AMR-Average-Daily-Weekly-Monthly-Range-Traders-Reality/ | SmartMoneyConceptsOnYouTube | https://www.tradingview.com/u/SmartMoneyConceptsOnYouTube/ | 164 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// Created by infernix, peshocore and xtech5192 - stripped down to ADR/AWR/AMR by divinasion
// Please note while the code is open source and you are free to use it however you like - the 'Traders Reality' name is not - ie if you produce derivatives of this
// source code you are to name those scripts using "Traders Reality", "Pattern Watchers" or any other name that relates to Traders Reality in any way.
//@version=5
indicator('TR ADR/AWR/AMR', overlay=true, max_bars_back=300, max_lines_count=500, max_labels_count=500)
//change ADR line width by editing line.set_width(id=x_line, width=2) below
// Config
adr_offset_input = input.int(group='Label offsets', title='ADR', defval=25, inline='labeloffset1')
adr_offset_input_50 = input.int(group='Label offsets', title='50% ADR', defval=85, inline='labeloffset1')
showADR = input.bool(group='Average Daily Range - ADR', title='Show ADR?', defval=true, inline='adr')
showADR_DO = input.bool(group='Average Daily Range - ADR', title='Use Daily Open (DO) calc?', defval=false, inline='adr', tooltip='Measure the ADR from the daily open. This will make the ADR static throughout the day. ADR is usually measured taking today high and low. Since todays high and low will change throughout the day, some might prefer to have a static range instead.')
showADRLabels = input.bool(group='Average Daily Range - ADR', title='Labels?', defval=true, inline='adr1')
showADRRange = input.bool(group='Average Daily Range - ADR', title='Range label?', defval=false, inline='adr1')
showADR_50 = input.bool(group='Average Daily Range - ADR', title='Show 50% ADR?', defval=false, inline='adr1')
aDRRange = input.int(group='Average Daily Range - ADR', title='ADR length (days)?', defval=14, minval=1, maxval=31, step=1, inline='adr2', tooltip="Defaults taken from mt4. This defines how many days back to take into consideration when calculating the ADR")
adrColor = input.color(group='Average Daily Range - ADR', title='ADR Color', defval=color.new(color.silver, 50), inline='adr3')
string adrStyleX = input.string(group='Average Daily Range - ADR', defval='Dotted', title='ADR Line Style', options=['Dotted', 'Dashed', 'Solid'], inline='adr3')
adrStyle = adrStyleX == 'Dotted' ? line.style_dotted : (adrStyleX == 'Dashed' ? line.style_dashed : (adrStyleX == 'Solid' ? line.style_solid : line.style_dotted))
showAWR = input.bool(group='Average Weekly Range - AWR', title='Show AWR?', defval=false, inline='awr')
showAWR_WO = input.bool(group='Average Weekly Range - AWR', title='Use Weekly Open (WO) calc?', defval=false, inline='awr', tooltip='Measure the AWR from the weekly open. This will make the AWR static throughout the week. AWR is usually measured taking this weeks high and low. Since this weeks high and low will change throughout the week, some might prefer to have a static range instead.')
showAWRLabels = input.bool(group='Average Weekly Range - AWR', title='Labels?', defval=true, inline='awr1')
showAWRRange = input.bool(group='Average Weekly Range - AWR', title='Range label?', defval=false, inline='awr1')
showAWR_50 = input.bool(group='Average Weekly Range - AWR', title='Show 50% AWR?', defval=false, inline='awr1')
aWRRange = input.int(group='Average Weekly Range - AWR', title='AWR length (weeks)?', defval=4, minval=1, maxval=52, step=1, inline='awr2', tooltip="Defaults taken from mt4. This defines how many weeks back to take into consideration when calculating the AWR")
awrColor = input.color(group='Average Weekly Range - AWR', title='AWR Color', defval=color.new(color.orange, 50), inline='awr3')
string awrStyleX = input.string(group='Average Weekly Range - AWR', defval='Dotted', title='AWR Line Style', options=['Dotted', 'Dashed', 'Solid'], inline='awr3')
awrStyle = awrStyleX == 'Dotted' ? line.style_dotted : (awrStyleX == 'Dashed' ? line.style_dashed : (awrStyleX == 'Solid' ? line.style_solid : line.style_dotted))
showAMR = input.bool(group='Average Monthly Range - AMR', title='Show AMR?', defval=false, inline='amr')
showAMR_MO = input.bool(group='Average Monthly Range - AMR', title='Use Monthly Open (MO) calc?', defval=false, inline='amr',tooltip='Measure the AMR from the monthly open. This will make the AMR static throughout the month. AMR is usually measured taking this months high and low. Since this months high and low will change throughout the month, some might prefer to have a static range instead.')
showAMRLabels = input.bool(group='Average Monthly Range - AMR', title='Labels?', defval=true, inline='amr1')
showAMRRange = input.bool(group='Average Monthly Range - AMR', title='Range label?', defval=false, inline='amr1')
showAMR_50 = input.bool(group='Average Monthly Range - AMR', title='Show 50% AMR?', defval=false, inline='amr1')
aMRRange = input.int(group='Average Monthly Range - AMR', title='AMR length (months)?', defval=6, minval=1, maxval=12, step=1, inline='amr2', tooltip="Defaults taken from mt4. This defines how many months back to take into consideration when calculating the AMR")
amrColor = input.color(group='Average Monthly Range - AMR', title='AMR Color', defval=color.new(color.red, 50), inline='amr3')
string amrStyleX = input.string(group='Average Monthly Range - AMR', defval='Dotted', title='AMR Line Style', options=['Dotted', 'Dashed', 'Solid'], inline='amr3')
amrStyle = amrStyleX == 'Dotted' ? line.style_dotted : (amrStyleX == 'Dashed' ? line.style_dashed : (amrStyleX == 'Solid' ? line.style_solid : line.style_dotted))
showAdrTable = input.bool(group='ADR/ADRx3/AWR/AMR Table', title='Show ADR Table', inline='adrt', defval=true)
showAdrPips = input.bool(group='ADR/ADRx3/AWR/AMR Table', title='Show ADR PIPS', inline='adrt', defval=true) and showAdrTable
showAdrCurrency = input.bool(group='ADR/ADRx3/AWR/AMR Table', title='Show ADR Currency', inline='adrt', defval=false) and showAdrTable
choiceAdrTable = input.string(group='ADR/ADRx3/AWR/AMR Table', title='ADR Table postion', inline='adrt', defval='top_right', options=['top_right', 'top_left', 'top_center', 'bottom_right', 'bottom_left', 'bottom_center'])
adrTableBgColor = input.color(group='ADR/ADRx3/AWR/AMR Table', title='ADR Table: Background Color', inline='adrtc', defval=color.rgb(93, 96, 107, 70))
adrTableTxtColor = input.color(group='ADR/ADRx3/AWR/AMR Table', title='Text Color', inline='adrtc', defval=color.rgb(31, 188, 211, 0))
//Non repainting security
f_security(_symbol, _res, _src, _repaint) =>
request.security(_symbol, _res, _src[_repaint ? 0 : barstate.isrealtime ? 1 : 0])[_repaint ? 0 : barstate.isrealtime ? 0 : 1]
// Basic vars (needed in functions)
// Only render intraday
validTimeFrame = timeframe.isintraday == true
// Functions
// new_bar: check if we're on a new bar within the session in a given resolution
new_bar(res) =>
ta.change(time(res)) != 0
// adr: Calculate average daily range for a given length
adr(length, barsBack) =>
// This is effectively an atr, which is what is used in MT4 to get those levels. FWIW, true range can be also calculated with tr(true)
trueRange = na(high[1]) ? high - low : math.max(math.max(high - low, math.abs(high - close[1])), math.abs(low - close[1]))
// Switched to SMA from RMA because somehow it matches MT4 better
ta.sma(trueRange[barsBack], length)
// adr_high: Calculate the ADR high given an ADR
adr_high(adr, from_do) =>
retVal = 0.0
if not from_do
retVal := high - low < adr ? low + adr : close >= open ? low + adr : high
else
retVal := open + adr
retVal
// adr_low: Calculate the ADR low given an ADR
adr_low(adr, from_do) =>
retVal = 0.0
if not from_do
retVal := high - low < adr ? high - adr : close >= open ? low : high - adr
else
retVal := open - adr
retVal
// to_pips: Convert to pips
to_pips(val) =>
pipSizeCalc = syminfo.mintick * (syminfo.type == "forex" ? 10 : 1)
returnVal = val/pipSizeCalc
returnVal
adr_label_x_offset = time_close + adr_offset_input * timeframe.multiplier * 60 * 1000
adr_label_x_offset_50 = time_close + adr_offset_input_50 * timeframe.multiplier * 60 * 1000
//Right_Label
r_label_offset(ry, rtext, rstyle, rcolor, valid, labelOffset) =>
if valid and barstate.isrealtime
rLabel = label.new(x=labelOffset, y=ry, text=rtext, xloc=xloc.bar_time, style=rstyle, textcolor=rcolor, textalign=text.align_right)
label.delete(rLabel[1])
draw_line(x_series, res, tag, xColor, xStyle, xWidth, xExtend, isLabelValid, xLabelOffset) =>
var line x_line = na
if validTimeFrame and new_bar(res) //and barstate.isnew
x_line := line.new(bar_index, x_series, bar_index+1, x_series, extend=xExtend, color=xColor, style=xStyle, width=xWidth)
line.set_width(id=x_line, width=1)
line.delete(x_line[1])
if not na(x_line) and not new_bar(res)//and line.get_x2(x_line) != bar_index
line.set_x2(x_line, bar_index)
line.set_y1(x_line,x_series)
line.set_y2(x_line,x_series)
if isLabelValid //showADRLabels and validTimeFrame
x_label = label.new(xLabelOffset, x_series, tag, xloc=xloc.bar_time, style=label.style_none, textcolor=xColor)
label.delete(x_label[1])
// if isLabelValid //showADRLabels and validTimeFrame
// pivot_label = label.new(pivot_label_x_offset, pivot_level, tag, xloc=xloc.bar_time, style=label.style_none, textcolor=pivotLabelColor, textalign=text.align_right)
// label.delete(pivot_label[1])
// if not barstate.islast
// line.set_x2(pivot_line, x=bar_index)
// else
// line.set_xloc(pivot_line, levelsstart, time_close + 1 * 86400000, xloc=xloc.bar_time)
// pivot_line
// Get Daily price data
dayHigh = f_security(syminfo.tickerid, 'D', high, false)
dayLow = f_security(syminfo.tickerid, 'D', low, false)
dayOpen = f_security(syminfo.tickerid, 'D', open, false)
dayClose = f_security(syminfo.tickerid, 'D', close, false)
//ADR
// Daily ADR
day_adr = request.security(syminfo.tickerid, 'D', adr(aDRRange,1), lookahead=barmerge.lookahead_on)
day_adr_high = request.security(syminfo.tickerid, 'D', showADR_DO ? adr_high(day_adr, true) : adr_high(day_adr, false), lookahead=barmerge.lookahead_on)
day_adr_low = request.security(syminfo.tickerid, 'D', showADR_DO ? adr_low(day_adr, true) : adr_low(day_adr, false), lookahead=barmerge.lookahead_on)
day_adr_high_50 = day_adr_high - (day_adr/2)
day_adr_low_50 = day_adr_low + (day_adr/2)
if showADR
string hl = 'Hi-ADR'+ (showADR_DO?'(DO)':'')
string ll = 'Lo-ADR'+ (showADR_DO?'(DO)':'')
draw_line(day_adr_high, 'D', hl, adrColor, adrStyle, 2, extend.right, showADRLabels and validTimeFrame, adr_label_x_offset)
draw_line(day_adr_low, 'D', ll, adrColor, adrStyle, 2, extend.right, showADRLabels and validTimeFrame, adr_label_x_offset)
r_label_offset((day_adr_high + day_adr_low) / 2, 'ADR ' + str.format('{0,number,#.##}', to_pips(day_adr)) + 'PIPS|' + str.tostring(day_adr, format.mintick) + syminfo.currency, label.style_none, adrColor, showADRLabels and validTimeFrame and showADRRange, adr_label_x_offset) //ry, rtext, rstyle, rcolor, valid
if showADR and showADR_50
string hl = '50% Hi-ADR'+ (showADR_DO?'(DO)':'')
string ll = '50% Lo-ADR'+ (showADR_DO?'(DO)':'')
draw_line(day_adr_high_50, 'D', hl, adrColor, adrStyle, 2, extend.right, showADRLabels and validTimeFrame, adr_label_x_offset_50)
draw_line(day_adr_low_50, 'D', ll, adrColor, adrStyle, 2, extend.right, showADRLabels and validTimeFrame, adr_label_x_offset_50)
r_label_offset((day_adr_high_50 + day_adr_low_50) / 2, '50% ADR ' + str.format('{0,number,#.##}', to_pips(day_adr/2)) + 'PIPS|' + str.tostring(day_adr/2, format.mintick) + syminfo.currency, label.style_none, adrColor, showADRLabels and validTimeFrame and showADRRange, adr_label_x_offset_50) //ry, rtext, rstyle, rcolor, valid
alertcondition(close >= day_adr_high and day_adr_high != 0.0 , "ADR High reached", "PA has reached the calculated ADR High")
alertcondition(close <= day_adr_low and day_adr_low != 0.0 , "ADR Low reached", "PA has reached the calculated ADR Low")
alertcondition(close >= day_adr_high_50 and day_adr_high_50 != 0.0 , "50% of ADR High reached", "PA has reached 50% of the calculated ADR High")
alertcondition(close <= day_adr_low_50 and day_adr_low_50 != 0.0 , "50% ADR Low reached", "PA has reached 50% the calculated ADR Low")
//Weekly ADR
week_adr = request.security(syminfo.tickerid, 'W', adr(aWRRange,1), lookahead=barmerge.lookahead_on)
week_adr_high = request.security(syminfo.tickerid, 'W', showAWR_WO ? adr_high(week_adr, true) : adr_high(week_adr, false), lookahead=barmerge.lookahead_on)
week_adr_low = request.security(syminfo.tickerid, 'W', showAWR_WO ? adr_low(week_adr, true) : adr_low(week_adr, false), lookahead=barmerge.lookahead_on)
week_adr_high_50 = week_adr_high - (week_adr/2)
week_adr_low_50 = week_adr_low + (week_adr/2)
if showAWR
string hl = 'Hi-AWR'+ (showAWR_WO?'(WO)':'')
string ll = 'Lo-AWR'+ (showAWR_WO?'(WO)':'')
draw_line(week_adr_high, 'W', hl, awrColor, awrStyle, 1, extend.right, showAWRLabels and validTimeFrame, adr_label_x_offset)
draw_line(week_adr_low, 'W', ll, awrColor, awrStyle, 1, extend.right, showAWRLabels and validTimeFrame, adr_label_x_offset)
r_label_offset((week_adr_high + week_adr_low) / 2, 'AWR ' + str.format('{0,number,#.##}', to_pips(week_adr)) + 'PIPS|' + str.tostring(week_adr, format.mintick) + syminfo.currency, label.style_none, awrColor, showAWRLabels and validTimeFrame and showAWRRange, adr_label_x_offset) //ry, rtext, rstyle, rcolor, valid
if showAWR and showAWR_50
string hl = '50% Hi-AWR'+ (showAWR_WO?'(WO)':'')
string ll = '50% Lo-AWR'+ (showAWR_WO?'(WO)':'')
draw_line(week_adr_high_50, 'W', hl, awrColor, awrStyle, 1, extend.right, showAWRLabels and validTimeFrame, adr_label_x_offset_50)
draw_line(week_adr_low_50, 'W', ll, awrColor, awrStyle, 1, extend.right, showAWRLabels and validTimeFrame, adr_label_x_offset_50)
r_label_offset((week_adr_high_50 + week_adr_low_50) / 2, '50% AWR ' + str.format('{0,number,#.##}', to_pips(week_adr/2)) + 'PIPS|' + str.tostring(week_adr/2, format.mintick) + syminfo.currency, label.style_none, awrColor, showAWRLabels and validTimeFrame and showAWRRange, adr_label_x_offset_50) //ry, rtext, rstyle, rcolor, valid
alertcondition(close >= week_adr_high and week_adr_high != 0 , "AWR High reached", "PA has reached the calculated AWR High")
alertcondition(close <= week_adr_low and week_adr_low != 0 , "AWR Low reached", "PA has reached the calculated AWR Low")
alertcondition(close >= week_adr_high_50 and week_adr_high_50 != 0 , "50% of AWR High reached", "PA has reached 50% of the calculated AWR High")
alertcondition(close <= week_adr_low_50 and week_adr_low_50 != 0 , "50% AWR Low reached", "PA has reached 50% of the calculated AWR Low")
//Monthly ADR
month_adr = request.security(syminfo.tickerid, 'M', adr(aMRRange,1), lookahead=barmerge.lookahead_on)
month_adr_high = request.security(syminfo.tickerid, 'M', showAMR_MO ? adr_high(month_adr, true) : adr_high(month_adr, false), lookahead=barmerge.lookahead_on)
month_adr_low = request.security(syminfo.tickerid, 'M', showAMR_MO ? adr_low(month_adr, true) : adr_low(month_adr, false), lookahead=barmerge.lookahead_on)
month_adr_high_50 = month_adr_high - (month_adr/2)
month_adr_low_50 = month_adr_low + (month_adr/2)
if showAMR and timeframe.isminutes and timeframe.multiplier >= 3
string hl = 'Hi-AMR'+ (showAMR_MO?'(MO)':'')
string ll = 'Lo-AMR'+ (showAMR_MO?'(MO)':'')
draw_line(month_adr_high, 'M', hl, amrColor, amrStyle, 1, extend.right, showAMRLabels and validTimeFrame, adr_label_x_offset)
draw_line(month_adr_low, 'M', ll, amrColor, amrStyle, 1, extend.right, showAMRLabels and validTimeFrame, adr_label_x_offset)
r_label_offset((month_adr_high + month_adr_low) / 2, 'AMR ' + str.format('{0,number,#.##}', to_pips(month_adr)) + 'PIPS|' + str.tostring(month_adr, format.mintick) + syminfo.currency, label.style_none, amrColor, showAMRLabels and validTimeFrame and showAMRRange,adr_label_x_offset) //ry, rtext, rstyle, rcolor, valid
if showAMR and showAMR_50 and timeframe.isminutes and timeframe.multiplier >= 3
string hl = '50% Hi-AMR'+ (showAMR_MO?'(MO)':'')
string ll = '50% Lo-AMR'+ (showAMR_MO?'(MO)':'')
draw_line(month_adr_high_50, 'M', hl, amrColor, amrStyle, 1, extend.right, showAMRLabels and validTimeFrame, adr_label_x_offset_50)
draw_line(month_adr_low_50, 'M', ll, amrColor, amrStyle, 1, extend.right, showAMRLabels and validTimeFrame, adr_label_x_offset_50)
r_label_offset((month_adr_high_50 + month_adr_low_50) / 2, '50% AMR ' + str.format('{0,number,#.##}', to_pips(month_adr/2)) + 'PIPS|' + str.tostring(month_adr/2, format.mintick) + syminfo.currency, label.style_none, amrColor, showAMRLabels and validTimeFrame and showAMRRange,adr_label_x_offset_50) //ry, rtext, rstyle, rcolor, valid
alertcondition(close >= month_adr_high and month_adr_high != 0 , "AMR High reached", "PA has reached the calculated AMR High")
alertcondition(close <= month_adr_low and month_adr_low != 0 , "AMR Low reached", "PA has reached the calculated AMR Low")
alertcondition(close >= month_adr_high_50 and month_adr_high_50 != 0 , "50% of AMR High reached", "PA has reached 50% of the calculated AMR High")
alertcondition(close <= month_adr_low_50 and month_adr_low_50 != 0 , "50% of AMR Low reached", "PA has reached 50% of the calculated AMR Low")
if barstate.islast and showAdrTable and validTimeFrame
if showAdrPips or showAdrCurrency
var table panel = table.new(choiceAdrTable, 2, 16, bgcolor=adrTableBgColor)
// Table header.
table.cell(panel, 0, 0, '')
table.cell(panel, 1, 0, '')
if showAdrPips
table.cell(panel, 0, 2, 'ADR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 2, str.format('{0,number,#.##}', to_pips(day_adr)) + "PIPS" , text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 3, 'ADRx3', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 3, str.format('{0,number,#.##}', to_pips(day_adr) * 3)+ "PIPS", text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 4, 'AWR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 4, str.format('{0,number,#.##}', to_pips(week_adr)) + "PIPS", text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 5, 'AMR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 5, str.format('{0,number,#.##}', to_pips(month_adr)) + "PIPS", text_color=adrTableTxtColor, text_halign=text.align_left)
if showAdrCurrency
table.cell(panel, 0, 6, 'ADR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 6, str.tostring(day_adr, format.mintick) + syminfo.currency, text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 7, 'ADRx3', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 7, str.tostring(day_adr * 3, format.mintick) + syminfo.currency, text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 8, 'AWR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 8, str.tostring(week_adr, format.mintick) + syminfo.currency, text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 0, 9, 'AMR', text_color=adrTableTxtColor, text_halign=text.align_left)
table.cell(panel, 1, 9, str.tostring(month_adr, format.mintick) + syminfo.currency, text_color=adrTableTxtColor, text_halign=text.align_left)
|
RSI Exponential Smoothing (Expo) | https://www.tradingview.com/script/OhFeqKQX-RSI-Exponential-Smoothing-Expo/ | Zeiierman | https://www.tradingview.com/u/Zeiierman/ | 1,141 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © Zeiierman
//@version=5
indicator("RSI Exponential Smoothing (Expo)", overlay=true)
// ~~ Inputs {
rsiperiod = input.int(14,minval=2, title="RSI Period", inline="RSI")
ob = input.int(70,minval=50, maxval=100, title="Overbought", inline="obos")
os = input.int(30,minval=0, maxval=50, title="Oversold", inline="obos")
obosbands = input.bool(true, title="OBOS Band", inline="RSI")
fibbands = input.bool(false, title="FIB Band", inline="RSI")
labels = input.bool(true, title="RSI Labels", inline="RSI")
// ~~ Line Colors {
ema_col = input.color(color.rgb(0, 0, 255), title="EMA",inline="c")
ema_ob_col = input.color(color.rgb(77, 255, 41), title="OB",inline="c")
ema_os_col = input.color(color.rgb(255, 65, 47), title="OS",inline="c")
ema_fib_col= input.color(color.blue, title="FIB",inline="c")
//~~~}
// ~~ Table Inputs {
showTable = input.bool(true,title="Show Table", inline="tbl", group="Table")
validity_check = input.bool(false,title="Show Validity check", inline="tbl", group="Table")
TblSize = input.string(size.normal,title="",options=[size.auto,size.tiny,size.small,size.normal,size.large,size.huge],inline="tbl", group="Table")
pos = input.string(position.top_right, title="",options =[position.top_right,position.top_center,
position.top_left,position.bottom_right,position.bottom_center,position.bottom_left,position.middle_right,position.middle_left],inline="tbl", group="Table")
textcolor = input.color(color.white, title="Text",inline="tbl_col", group="Table")
bgcolor = input.color(color.new(color.blue,30), title="Bg",inline="tbl_col", group="Table")
postrend = input.color(color.new(color.lime,0), title="Trend",inline="tbl_col", group="Table")
negtrend = input.color(color.new(color.red,0), title="",inline="tbl_col", group="Table")
ob_col = input.color(color.new(color.lime,0), title="OB/OS",inline="tbl_col", group="Table")
os_col = input.color(color.new(color.red,0), title="",inline="tbl_col", group="Table")
//~~~}
//~~~~~~}
// ~~ EMA RSI Approx Calculation {
// ~~ Exponential Smoothing Coefficient Calculation {
exponential_period = 2 * rsiperiod - 1 // "exponential_period" is the length of the moving average, represented as "2 * rsiperiod - 1", where "rsiperiod" is a user-defined value.
smoothing_coefficient = 2 / (exponential_period + 1) // "smoothing_coefficient" is a value used to calculate the EMA, represented as "2 / (exponential_period + 1)". This value determines the weight given to the current observation versus the previous average in the calculation.
//~~~}
// ~~ Exponential Smoothing RSI Calculation {
// The code calculates two running averages, "averageUp" and "averageDown", using the exponential smoothing formula with the smoothing coefficient value defined in the previous code snippet.
// The "netValue" variable is then calculated as the weighted difference between the "averageUp" and "averageDown" values, with a factor determined by the user-defined "rsiperiod" value.
// The "result" variable is calculated based on the sign of "netValue". If "netValue" is positive, the result is equal to the current close price plus "netValue". If "netValue" is negative, the result is equal to the close price plus a fraction of "netValue" determined by the "level" parameter
emaresult(level)=>
averageUp = 0.0
averageDown = 0.0
averageUp := close > close[1] ? smoothing_coefficient* (close - close[1]) + (1 - smoothing_coefficient) * (averageUp[1] ? averageUp[1] : 1) : (1-smoothing_coefficient) * (averageUp[1] ? averageUp[1] : 1)
averageDown := close > close[1] ? (1-smoothing_coefficient) * (averageDown[1] ? averageDown[1] : 1) : smoothing_coefficient * (close[1] - close) + (1 - smoothing_coefficient) * (averageDown[1] ? averageDown[1] : 1)
netValue = (rsiperiod - 1) * (averageDown * level / (100 - level) - averageUp)
result = netValue >= 0 ? close + netValue : close + netValue * (100 - level) / level
//~~~}
// ~~ Return EMA {
ema_result = emaresult(50)
// Plot the Optimal EMA based on the RSI value
plot(ema_result, color=ema_col, title="Optimal EMA")
//~~~}
//~~~~~~}
// ~~ Calculate RSI Standard Deviation, in order to calculate the Deviation {
StandardDeviation(src, period)=>
mean = ta.sma(src, period)
squared_diff = ((src - mean) * (src - mean))
sum_squared_diff = math.sum(squared_diff, period)
std_dev = math.sqrt(sum_squared_diff/period)
//~~~}
// ~~ Return RSI Standard Deviation {
rsi = ta.rsi(close,rsiperiod)
std_dev = StandardDeviation(rsi, rsiperiod)
//~~~}
// ~~ Calculate Deviation {
//It calculates the difference between the RSI value of (level) and the RSI mean value, then divides that difference by the standard deviation.
//This number represents how many standard deviations away the RSI Level is from its mean.
dev(obos)=>
deviating = (obos-ema_result)/std_dev
//~~~}
// ~~ Hull Moving Average Calculation, in order to smooth the Upper OB and Lower OS lines {
hma(src,len)=>
wma1 = ta.wma(2 * ta.wma(src, len/2) - ta.wma(src, len), math.round(math.sqrt(0.5)))
wma2 = ta.wma(2 * ta.wma(wma1, len/2) - ta.wma(wma1, len), math.round(math.sqrt(0.5)))
//~~~}
// ~~ Return EMA OB/OS Lines {
// Deviation refers to how far a data point is from the mean (average) of the data set. It is calculated as the difference between the data point and the mean.
// Standard deviation is a measure of how much the values in a data set vary around the mean. It provides a summary of the distribution of the data.
// When the deviation of a data point is multiplied by the standard deviation, it gives us a measure of how many standard deviations away from the mean the data point is.
// This measure is useful in understanding the level of variation in the data set and making predictions about the data.
// The deviation * stdev is used to add an offset to the EMA calculation
// It returns the Upper Overbougth and Lower Oversold levels on the chart.
ob_dev = dev(emaresult(ob)) // The deviation of the OB level from the mean. This number represents how many standard deviations away the OB Level is from its mean.
os_dev = dev(emaresult(os)) // The deviation of the OS level from the mean. This number represents how many standard deviations away the OS Level is from its mean.
upper = hma(ta.rma(ema_result + (ob_dev*std_dev),3),10) // Returns the upper OB line on the chart.
lower = hma(ta.rma(ema_result + (os_dev*std_dev),3),10) // Returns the upper OS line on the chart.
// ~~ Plot Upper OB and Lower OS lines on the chart {
plot(obosbands?upper:na, "Upper OB", color=ema_ob_col)
plot(obosbands?lower:na, "Lower OS", color=ema_os_col)
plot(obosbands?upper - ta.stdev(upper,2):na, "Upper OB", color=ema_ob_col)
plot(obosbands?lower + ta.stdev(lower,2):na, "Lower OS", color=ema_os_col)
//~~~}
//~~~~~~}
// ~~ Calculate fib 50% from OB to 50 level and OS to 50 level {
fib(src)=>
fib = ema_result + (src-ema_result)*0.5
// ~~ Plot the Fib lines on the chart {
plot(fibbands?fib(upper):na, "Upper Fib 50%", color=ema_fib_col)
plot(fibbands?fib(lower):na, "Lower Fib 50%", color=ema_fib_col)
//~~~}
//~~~~~~}
// ~~ Validity Checks {
// ~~ Store crossover values to check Validity {
// ~~ Optimal EMA Length {
emavalue = 2*rsiperiod-1
ema = ta.ema(close,emavalue)
//~~~}
var occurrence = 0
var non_occurrence = 0
if (ta.crossover(rsi,50) and ta.crossover(close,ema)) or (ta.crossunder(rsi,50) and ta.crossunder(close,ema))
occurrence += 1
if (ta.crossover(rsi,50) and not ta.crossover(close,ema)) or (ta.crossunder(rsi,50) and not ta.crossunder(close,ema))
non_occurrence += 1
//~~~~~~}
// ~~ Precentage Check {
//The resulting value tells you how many occurrences there are relative to the total number of events, expressed as a percentage.
percent = ((math.abs(occurrence)/(occurrence + non_occurrence) * 100))
//~~~}
// ~~ Inputs to Table {
// ~~ Trend Direction {
dir = rsi>50?true:false
sign = dir == true?" > 50 ":" < 50"
trend = dir == true?"Bullish":"Bearish"
col = dir == true?postrend:negtrend
//~~~}
// ~~ Overbought & Oversold {
ob_ = rsi>ob ?true:false
os_ = rsi<os?true:false
obos_sign = ob_? " > " + str.tostring(ob):os_? " < " + str.tostring(os):""
obos_text = ob_? "Overbought":os_? "Oversold":""
obos_col = ob_?ob_col:os_?os_col:color.white
//~~~}
//~~~~~~}
// ~~ Table {
tbl = table.new(pos, 2, 11, frame_color=chart.bg_color, frame_width=2, border_width=2, border_color=chart.bg_color)
if barstate.islast and showTable
tbl.cell(0, 0, text="RSI Value", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(0, 1, text=str.tostring(rsiperiod), text_halign=text.align_center, bgcolor=bgcolor, text_color=textcolor, text_size=TblSize)
tbl.cell(1, 0, text="EMA Value", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(1, 1, text=str.tostring(emavalue), text_halign=text.align_center, bgcolor=bgcolor, text_color=textcolor, text_size=TblSize)
tbl.cell(0, 2, text="RSI" + sign + "", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(1, 2, text=trend, text_halign=text.align_center, bgcolor=col, text_color=textcolor, text_size=TblSize)
if (ob_) or (os_)
tbl.cell(0, 3, text="RSI" + obos_sign + "", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(1, 3, text=obos_text, text_halign=text.align_center, bgcolor=obos_col, text_color=textcolor, text_size=TblSize)
if validity_check
tbl.cell(0, 4, text="Validity Check", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(1, 4, text=str.tostring(percent,format.percent), text_halign=text.align_center, bgcolor=color.new(color.lime,30), text_color=textcolor, text_size=TblSize)
tbl.cell(0, 5, text="RSI Stdev", text_color=textcolor, bgcolor=bgcolor, text_size=TblSize)
tbl.cell(1, 5, text=str.tostring(math.round(std_dev)), text_halign=text.align_center, bgcolor=color.new(color.lime,30), text_color=textcolor, text_size=TblSize)
// ~~ Labels {
labelfunc(bool_,n, line_, text_, label_col, text_col, size_)=>
label l = bool_?label.new(bar_index + n,line_,text=text_,color=label_col,
style=label.style_label_left,textcolor=text_col,size=size_,
textalign=text.align_left):na
label.delete(l[1])
labelfunc(labels,5, ema_result, "RSI 50" , color.blue, color.white, size.small)
labelfunc(labels,5, upper, "RSI " + str.tostring(ob) , color.green, color.white, size.small)
labelfunc(labels,5, lower, "RSI " + str.tostring(os) , color.red, color.white, size.small)
labelfunc(fibbands and labels,1, fib(upper), "FIB 50 %" , color.blue, color.white, size.tiny)
labelfunc(fibbands and labels,1, fib(lower), "FIB 50 %" , color.blue, color.white, size.tiny)
//~~~}
|
Bullish Pennant Patterns [theEccentricTrader] | https://www.tradingview.com/script/6bIHOBHs-Bullish-Pennant-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 31 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bullish Pennant Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 350)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
onePartReturnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
twoPartReturnLineUptrend = onePartReturnLineUptrend and ta.valuewhen(shPrice, shPrice, 1) > ta.valuewhen(shPrice, shPrice, 2)
threePartReturnLineUptrend = twoPartReturnLineUptrend and ta.valuewhen(shPrice, shPrice, 2) > ta.valuewhen(shPrice, shPrice, 3)
onePartDowntrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
twoPartDowntrend = onePartDowntrend and ta.valuewhen(shPrice, shPrice, 1) < ta.valuewhen(shPrice, shPrice, 2)
threePartDowntrend = twoPartDowntrend and ta.valuewhen(shPrice, shPrice, 2) < ta.valuewhen(shPrice, shPrice, 3)
onePartUptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
twoPartUptrend = onePartUptrend and ta.valuewhen(slPrice, slPrice, 1) > ta.valuewhen(slPrice, slPrice, 2)
threePartUptrend = twoPartUptrend and ta.valuewhen(slPrice, slPrice, 2) > ta.valuewhen(slPrice, slPrice, 3)
onePartReturnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
twoPartReturnLineDowntrend = onePartReturnLineDowntrend and ta.valuewhen(slPrice, slPrice, 1) < ta.valuewhen(slPrice, slPrice, 2)
threePartReturnLineDowntrend = twoPartReturnLineDowntrend and ta.valuewhen(slPrice, slPrice, 2) < ta.valuewhen(slPrice, slPrice, 3)
addUnbrokenPeak = input(defval = false, title = 'Unbroken Peaks', group = 'Logic')
unbrokenPeak = addUnbrokenPeak ? high < peak : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
abRatio = input(defval = 100, title = 'AB Minimum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
bullishPennant = slPrice and twoPartUptrend and onePartDowntrend and unbrokenPeak
and shRangeRatioOne >= abRatio
and slRangeRatioOne <= bcRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.green, title = 'Flag Color', group = 'Pattern Lines')
selectFlagExtend = input.string(title = 'Extend Current Flag Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendFlagLines = selectFlagExtend == 'None' ? extend.none : selectFlagExtend == 'Right' ? extend.right :
selectFlagExtend == 'Left' ? extend.left : selectFlagExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentResistanceLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentSupportLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bullishPennant
lineOne = line.new(slPriceBarIndexTwo, slPriceTwo, shPriceBarIndexOne, shPriceOne, color = poleColor, width = 2)
lineTwo = line.new(shPriceBarIndexOne, shPriceOne, peakBarIndex, peak, color = flagColor, width = 2)
lineThree = line.new(slPriceBarIndexOne, slPriceOne, slPriceBarIndex, slPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? slPriceBarIndex : na, showProjections ? slPrice : na, showProjections ? bar_index + 1 : na,
showProjections ? slPrice : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceOne - slPriceTwo) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? slPriceBarIndexTwo : na, showProjections ? slPriceTwo : na, showProjections ? bar_index + 1 : na,
showProjections ? slPriceTwo : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentResistanceLine, shPriceBarIndexOne, shPriceOne)
line.set_xy2(currentResistanceLine, peakBarIndex, peak)
line.set_xy1(currentSupportLine, slPriceBarIndexOne, slPriceOne)
line.set_xy2(currentSupportLine, slPriceBarIndex, slPrice)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1: na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? slPriceBarIndex : na, showProjections ? slPrice : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1: na, showProjections ? slPrice : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1: na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? slPriceBarIndexTwo : na, showProjections ? slPriceTwo : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1: na, showProjections ? slPriceTwo : na)
labelOne = label.new(showLabels ? slPriceBarIndexTwo : na, showLabels ? slPriceTwo : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'A', textcolor = labelColor)
labelTwo = label.new(showLabels ? shPriceBarIndexOne : na, showLabels ? shPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'B (' + str.tostring(math.round(shRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelThree = label.new(showLabels ? slPriceBarIndexOne : na, showLabels ? slPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'C (' + str.tostring(math.round(slRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelFour = label.new(showLabels ? peakBarIndex : na, showLabels ? peak : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'D (' + str.tostring(math.round(shRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelFive = label.new(showLabels ? slPriceBarIndex : na, showLabels ? slPrice : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'E (' + str.tostring(math.round(slRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
array.push(myLabelArray, labelFour)
array.push(myLabelArray, labelFive)
if array.size(myLabelArray) >= 350
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bullish Pennant')
|
Bullish Alternate Flag Patterns [theEccentricTrader] | https://www.tradingview.com/script/ZzQckj47-Bullish-Alternate-Flag-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 40 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bullish Alternate Flag Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 250)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
returnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
uptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
downtrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
returnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
addUnbrokenPeak = input(defval = false, title = 'Unbroken Peaks', group = 'Logic')
unbrokenPeak = addUnbrokenPeak ? high < peak : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
abRatio = input(defval = 100, title = 'AB Minimum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
bullishAlternateFlag = slPrice and uptrend and unbrokenPeak
and shRangeRatioZero >= abRatio
and slRangeRatio <= bcRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.green, title = 'Flag Color', group = 'Pattern Lines')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bullishAlternateFlag
lineOne = line.new(slPriceBarIndexOne, slPriceOne, peakBarIndex, peak, color = poleColor, width = 2)
lineTwo = line.new(peakBarIndex, peak, slPriceBarIndex, slPrice, color = flagColor, width = 2)
lineThree = line.new(slPriceBarIndex - 1, slPrice, slPriceBarIndex, slPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? slPrice : na, showProjections ? bar_index + 1 : na,
showProjections ? slPrice : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (peak - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (peak - slPriceOne) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? slPriceBarIndexOne : na, showProjections ? slPriceOne : na, showProjections ? bar_index + 1 : na,
showProjections ? slPriceOne : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (peak - slPriceOne) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? peak + (peak - slPriceOne) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? slPriceBarIndexOne : na, showProjections ? slPriceOne : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? slPriceOne : na)
labelOne = label.new(slPriceBarIndexOne, slPriceOne, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'A', textcolor = labelColor)
labelTwo = label.new(peakBarIndex, peak, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'B (' + str.tostring(math.round(shRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelThree = label.new(slPriceBarIndex, slPrice, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'C (' + str.tostring(math.round(slRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
if array.size(myLabelArray) >= 250
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bullish Alt. Flag')
|
Bearish Alternate Flag Patterns [theEccentricTrader] | https://www.tradingview.com/script/KnfqwsYn-Bearish-Alternate-Flag-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 42 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bearish Alternate Flag Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 250)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
returnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
uptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
downtrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
returnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
addUnbrokenTrough = input(defval = false, title = 'Unbroken Troughs', group = 'Logic')
unbrokenTrough = addUnbrokenTrough ? low > trough : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
abRatio = input(defval = 100, title = 'AB Maximum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
bearishAlternateFlag = shPrice and downtrend and unbrokenTrough
and slRangeRatioZero >= abRatio
and shRangeRatio <= bcRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.red, title = 'Flag Color', group = 'Pattern Lines')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bearishAlternateFlag
lineOne = line.new(shPriceBarIndexOne, shPriceOne, troughBarIndex, trough, color = poleColor, width = 2)
lineTwo = line.new(troughBarIndex, trough, shPriceBarIndex, shPrice, color = flagColor, width = 2)
lineThree = line.new(shPriceBarIndex - 1, shPrice, shPriceBarIndex, shPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? shPriceBarIndexOne : na, showProjections ? shPriceOne : na, showProjections ? bar_index + 1 : na,
showProjections ? shPriceOne : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - trough) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceOne - trough) : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? shPriceBarIndexOne : na, showProjections ? shPriceOne : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? shPriceOne : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - trough) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? trough - (shPriceOne - trough) : na)
labelOne = label.new(shPriceBarIndexOne, shPriceOne, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'A', textcolor = labelColor)
labelTwo = label.new(troughBarIndex, trough, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'B (' + str.tostring(math.round(slRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelThree = label.new(shPriceBarIndex, shPrice, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'C (' + str.tostring(math.round(shRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
if array.size(myLabelArray) >= 250
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bearish Alt. Flag')
|
Bearish Pennant Patterns [theEccentricTrader] | https://www.tradingview.com/script/5pJohzGI-Bearish-Pennant-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 34 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bearish Pennant Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 350)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
onePartReturnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
twoPartReturnLineUptrend = onePartReturnLineUptrend and ta.valuewhen(shPrice, shPrice, 1) > ta.valuewhen(shPrice, shPrice, 2)
threePartReturnLineUptrend = twoPartReturnLineUptrend and ta.valuewhen(shPrice, shPrice, 2) > ta.valuewhen(shPrice, shPrice, 3)
onePartDowntrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
twoPartDowntrend = onePartDowntrend and ta.valuewhen(shPrice, shPrice, 1) < ta.valuewhen(shPrice, shPrice, 2)
threePartDowntrend = twoPartDowntrend and ta.valuewhen(shPrice, shPrice, 2) < ta.valuewhen(shPrice, shPrice, 3)
onePartUptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
twoPartUptrend = onePartUptrend and ta.valuewhen(slPrice, slPrice, 1) > ta.valuewhen(slPrice, slPrice, 2)
threePartUptrend = twoPartUptrend and ta.valuewhen(slPrice, slPrice, 2) > ta.valuewhen(slPrice, slPrice, 3)
onePartReturnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
twoPartReturnLineDowntrend = onePartReturnLineDowntrend and ta.valuewhen(slPrice, slPrice, 1) < ta.valuewhen(slPrice, slPrice, 2)
threePartReturnLineDowntrend = twoPartReturnLineDowntrend and ta.valuewhen(slPrice, slPrice, 2) < ta.valuewhen(slPrice, slPrice, 3)
addUnbrokenTrough = input(defval = false, title = 'Unbroken Troughs', group = 'Logic')
unbrokenTrough = addUnbrokenTrough ? low > trough : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
beRangeRatio = (shPriceOne - trough) / (shPriceOne - slPriceTwo) * 100
abRatio = input(defval = 100, title = 'AB Minimum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
bearishPennant = shPrice and twoPartDowntrend and onePartUptrend and unbrokenTrough
and slRangeRatioOne >= abRatio
and shRangeRatioOne <= bcRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.red, title = 'Flag Color', group = 'Pattern Lines')
selectFlagExtend = input.string(title = 'Extend Current Flag Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendFlagLines = selectFlagExtend == 'None' ? extend.none : selectFlagExtend == 'Right' ? extend.right :
selectFlagExtend == 'Left' ? extend.left : selectFlagExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentResistanceLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentSupportLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bearishPennant
lineOne = line.new(shPriceBarIndexTwo, shPriceTwo, slPriceBarIndexOne, slPriceOne, color = poleColor, width = 2)
lineTwo = line.new(slPriceBarIndexOne, slPriceOne, troughBarIndex, trough, color = flagColor, width = 2)
lineThree = line.new(shPriceBarIndexOne, shPriceOne, shPriceBarIndex, shPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceTwo - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceTwo - slPriceOne) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceTwo - slPriceOne) : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentResistanceLine, shPriceBarIndexOne, shPriceOne)
line.set_xy2(currentResistanceLine, peakBarIndex, peak)
line.set_xy1(currentSupportLine, slPriceBarIndexOne, slPriceOne)
line.set_xy2(currentSupportLine, troughBarIndex, trough)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1: na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1: na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceTwo - slPriceOne) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1: na, showProjections ? peak + (shPriceTwo - slPriceOne) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1: na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
labelOne = label.new(showLabels ? shPriceBarIndexTwo : na, showLabels ? shPriceTwo : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'A', textcolor = labelColor)
labelTwo = label.new(showLabels ? slPriceBarIndexOne : na, showLabels ? slPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'B (' + str.tostring(math.round(slRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelThree = label.new(showLabels ? shPriceBarIndexOne : na, showLabels ? shPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'C (' + str.tostring(math.round(shRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelFour = label.new(showLabels ? troughBarIndex : na, showLabels ? trough : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'D (' + str.tostring(math.round(slRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelFive = label.new(showLabels ? shPriceBarIndex : na, showLabels ? shPrice : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'E (' + str.tostring(math.round(shRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
array.push(myLabelArray, labelFour)
array.push(myLabelArray, labelFive)
if array.size(myLabelArray) >= 350
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bearish Pennant')
|
Double Bottom Patterns [theEccentricTrader] | https://www.tradingview.com/script/orqK2H0P-Double-Bottom-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 74 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Double Bottom Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 63)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
addUnbrokenPeak = input(defval = false, title = 'Unbroken Peaks', group = 'Logic')
unbrokenPeak = addUnbrokenPeak ? high < peak : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
lowerTolerance = input(defval = 10, title = 'Lower Tolerance (%)', group = 'Tolerances')
upperTolerance = input(defval = 10, title = 'Upper Tolerance (%)', group = 'Tolerances')
doubleBottom = slPrice and unbrokenPeak
and slRangeRatio >= 100 - lowerTolerance
and slRangeRatio <= 100 + upperTolerance
//////////// lines ////////////
patternColor = input(defval = color.blue, title = 'Pattern Color', group = 'Pattern Lines')
necklineColor = input(defval = color.yellow, title = 'Neckline Color', group = 'Pattern Lines')
selectNecklineExtend = input.string(title = 'Extend Current Neckline Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendNeckLine = selectNecklineExtend == 'None' ? extend.none : selectNecklineExtend == 'Right' ? extend.right :
selectNecklineExtend == 'Left' ? extend.left : selectNecklineExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentNeckLine = line.new(na, na, na, na, extend = extendNeckLine, color = necklineColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if doubleBottom
lineOne = line.new(slPriceBarIndexOne, slPriceOne, peakBarIndex, peak, color = patternColor, width = 2)
lineTwo = line.new(peakBarIndex, peak, troughBarIndex, trough, color = patternColor, width = 2)
lineThree = line.new(slPriceBarIndexOne, slPriceOne, bar_index, slPriceOne, color = patternColor, width = 2)
lineFour = line.new(peakBarIndex, peak, bar_index, peak, color = necklineColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (peak - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (peak - slPriceOne) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (peak - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (peak - slPriceOne) : na, color = color.red, style = line.style_dashed)
labelOne = label.new(showLabels ? troughBarIndex : na, showLabels ? trough : na, 'DOUBLE BOTTOM', color = color.rgb(54, 58, 69, 100), style = label.style_label_up, textcolor = labelColor)
line.set_xy1(currentNeckLine, peakBarIndex, peak)
line.set_xy2(currentNeckLine, bar_index, peak)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (peak - slPriceOne) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? peak + (peak - slPriceOne) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (peak - slPriceOne) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? trough - (peak - slPriceOne) : na)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, lineFour)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
if array.size(myLabelArray) >= 63
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Double Bottom')
|
Triple Bottom Patterns [theEccentricTrader] | https://www.tradingview.com/script/c5ZLhANT-Triple-Bottom-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 76 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Triple Bottom Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 50)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
addUnbrokenPeak = input(defval = false, title = 'Unbroken Peaks', group = 'Logic')
unbrokenPeak = addUnbrokenPeak ? high < peak : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
thirdTroughRatio = (shPriceOne - trough) / (shPriceOne - slPriceTwo) * 100
lowerTolerance = input(defval = 10, title = 'Lower Tolerance (%)', group = 'Tolerances')
upperTolerance = input(defval = 10, title = 'Upper Tolerance (%)', group = 'Tolerances')
tripleBottom = slPrice and unbrokenPeak
and slRangeRatio >= 100 - lowerTolerance
and slRangeRatio <= 100 + upperTolerance
and thirdTroughRatio >= 100 - lowerTolerance
and thirdTroughRatio <= 100 + upperTolerance
//////////// lines ////////////
patternColor = input(defval = color.blue, title = 'Pattern Color', group = 'Pattern Lines')
necklineColor = input(defval = color.yellow, title = 'Neckline Color', group = 'Pattern Lines')
selectNecklineExtend = input.string(title = 'Extend Current Neckline Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendNeckLine = selectNecklineExtend == 'None' ? extend.none : selectNecklineExtend == 'Right' ? extend.right :
selectNecklineExtend == 'Left' ? extend.left : selectNecklineExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentNeckLine = line.new(na, na, na, na, extend = extendNeckLine, color = necklineColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if tripleBottom
lineOne = line.new(slPriceBarIndexTwo, slPriceTwo, shPriceBarIndexOne, shPriceOne, color = patternColor, width = 2)
lineTwo = line.new(shPriceBarIndexOne, shPriceOne, slPriceBarIndexOne, slPriceOne, color = patternColor, width = 2)
lineThree = line.new(slPriceBarIndexOne, slPriceOne, peakBarIndex, peak, color = patternColor, width = 2)
lineFour = line.new(peakBarIndex, peak, troughBarIndex, trough, color = patternColor, width = 2)
lineFive = line.new(slPriceBarIndexTwo, slPriceTwo, bar_index, slPriceTwo, color = patternColor, width = 2)
lineSix = line.new(peakBarIndex, peak, bar_index, peak, color = necklineColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceOne - slPriceTwo) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - slPriceTwo) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceOne - slPriceTwo) : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentNeckLine, peakBarIndex, peak)
line.set_xy2(currentNeckLine, bar_index, peak)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - slPriceTwo) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? trough - (shPriceOne - slPriceTwo) : na)
labelOne = label.new(showLabels ? troughBarIndex : na, showLabels ? trough : na, 'TRIPLE BOTTOM', color = color.rgb(54, 58, 69, 100), style = label.style_label_up, textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, lineFour)
array.push(myLineArray, lineFive)
array.push(myLineArray, lineSix)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
if array.size(myLabelArray) >= 50
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Triple Bottom')
|
Triple Top Patterns [theEccentricTrader] | https://www.tradingview.com/script/hENKHARI-Triple-Top-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 71 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Triple Top Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 50)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
addUnbrokenTrough = input(defval = false, title = 'Unbroken Troughs', group = 'Logic')
unbrokenTrough = addUnbrokenTrough ? low > trough : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
thirdPeakRatio = (peak - slPriceOne) / (shPriceTwo - slPriceOne) * 100
lowerTolerance = input(defval = 10, title = 'Lower Tolerance (%)', group = 'Tolerances')
upperTolerance = input(defval = 10, title = 'Upper Tolerance (%)', group = 'Tolerances')
tripleTop = shPrice and unbrokenTrough
and shRangeRatio >= 100 - lowerTolerance
and shRangeRatio <= 100 + upperTolerance
and thirdPeakRatio >= 100 - lowerTolerance
and thirdPeakRatio <= 100 + upperTolerance
//////////// lines ////////////
patternColor = input(defval = color.blue, title = 'Pattern Color', group = 'Pattern Lines')
necklineColor = input(defval = color.yellow, title = 'Neckline Color', group = 'Pattern Lines')
selectNecklineExtend = input.string(title = 'Extend Current Neckline Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendNeckLine = selectNecklineExtend == 'None' ? extend.none : selectNecklineExtend == 'Right' ? extend.right :
selectNecklineExtend == 'Left' ? extend.left : selectNecklineExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentNeckLine = line.new(na, na, na, na, extend = extendNeckLine, color = necklineColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if tripleTop
lineOne = line.new(shPriceBarIndexTwo, shPriceTwo, slPriceBarIndexOne, slPriceOne, color = patternColor, width = 2)
lineTwo = line.new(slPriceBarIndexOne, slPriceOne, shPriceBarIndexOne, shPriceOne, color = patternColor, width = 2)
lineThree = line.new(shPriceBarIndexOne, shPriceOne, troughBarIndex, trough, color = patternColor, width = 2)
lineFour = line.new(troughBarIndex, trough, peakBarIndex, peak, color = patternColor, width = 2)
lineFive = line.new(shPriceBarIndexTwo, shPriceTwo, bar_index, shPriceTwo, color = patternColor, width = 2)
lineSix = line.new(troughBarIndex, trough, bar_index, trough, color = necklineColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceTwo - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceTwo - slPriceOne) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceTwo - slPriceOne) : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentNeckLine, troughBarIndex, trough)
line.set_xy2(currentNeckLine, bar_index, trough)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceTwo - slPriceOne) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? peak + (shPriceTwo - slPriceOne) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
labelOne = label.new(showLabels ? peakBarIndex : na, showLabels ? peak : na, 'TRIPLE TOP', color = color.rgb(54, 58, 69, 100), style = label.style_label_down, textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, lineFour)
array.push(myLineArray, lineFive)
array.push(myLineArray, lineSix)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
if array.size(myLabelArray) >= 50
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Triple Top') |
Double Top Patterns [theEccentricTrader] | https://www.tradingview.com/script/2mGWaEbt-Double-Top-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 67 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Double Top Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 63)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
addUnbrokenTrough = input(defval = false, title = 'Unbroken Troughs', group = 'Logic')
unbrokenTrough = addUnbrokenTrough ? low > trough : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
bcLowerTolerance = input(defval = 10, title = 'BC Lower Tolerance (%)', group = 'Tolerances')
bcUpperTolerance = input(defval = 10, title = 'BC Upper Tolerance (%)', group = 'Tolerances')
doubleTop = shPrice and unbrokenTrough
and shRangeRatio >= 100 - bcLowerTolerance
and shRangeRatio <= 100 + bcUpperTolerance
//////////// lines ////////////
patternColor = input(defval = color.blue, title = 'Pattern Color', group = 'Pattern Lines')
necklineColor = input(defval = color.yellow, title = 'Neckline Color', group = 'Pattern Lines')
selectNecklineExtend = input.string(title = 'Extend Current Neckline Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendNeckLine = selectNecklineExtend == 'None' ? extend.none : selectNecklineExtend == 'Right' ? extend.right :
selectNecklineExtend == 'Left' ? extend.left : selectNecklineExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentNeckLine = line.new(na, na, na, na, extend = extendNeckLine, color = necklineColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if doubleTop
lineOne = line.new(shPriceBarIndexOne, shPriceOne, troughBarIndex, trough, color = patternColor, width = 2)
lineTwo = line.new(troughBarIndex, trough, peakBarIndex, peak, color = patternColor, width = 2)
lineThree = line.new(shPriceBarIndexOne, shPriceOne, bar_index, shPriceOne, color = patternColor, width = 2)
lineFour = line.new(troughBarIndex, trough, bar_index, trough, color = necklineColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - trough) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceOne - trough) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - trough) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceOne - trough) : na, color = color.red, style = line.style_dashed)
labelOne = label.new(showLabels ? peakBarIndex : na, showLabels ? peak : na, 'DOUBLE TOP', color = color.rgb(54, 58, 69, 100), style = label.style_label_down, textcolor = labelColor)
line.set_xy1(currentNeckLine, troughBarIndex, trough)
line.set_xy2(currentNeckLine, bar_index, trough)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1 : na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1 : na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - trough) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1 : na, showProjections ? peak + (shPriceOne - trough) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceOne - trough) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1 : na, showProjections ? trough - (shPriceOne - trough) : na)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, lineFour)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
if array.size(myLabelArray) >= 63
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Double Top') |
Price Extrapolator with Std Deviation | https://www.tradingview.com/script/P29PE06W-Price-Extrapolator-with-Std-Deviation/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 45 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator('Price Extrapolator with Log Normal Deviation', shorttitle='PE', overlay=true)
// Input for the length of historical data to calculate the average log return
length = input.int(14, 'Length', 1)
// Input for the number of future price points to extrapolate
num_future_points = input.int(5,'Number of Future Price Points', 1)
// Input for the deviation multiplier
factor = input.float(0.25, "Multiplier", 0, 2, 0.05) // Adjust this value between 0 and 1 to control the tightness of the cone
// Calculate the average log return over the specified length
log_returns = math.log(close / close[1])
avg_log_return = ta.sma(log_returns, length)
// Calculate the variance of log returns
log_returns_variance = ta.variance(log_returns, length)
// Calculate the log-normal deviation
log_normal_deviation = math.exp(math.sqrt(log_returns_variance)) - 1
// Initialize arrays to store the future price points and their standard deviations
var float[] future_prices = array.new_float(num_future_points)
var float[] upper_std_dev_prices = array.new_float(num_future_points)
var float[] lower_std_dev_prices = array.new_float(num_future_points)
// Fill the arrays with extrapolated price points and their standard deviations
for i = 0 to num_future_points - 1
if barstate.islast
array.set(future_prices, i, open * math.exp((i + 1) * avg_log_return))
array.set(upper_std_dev_prices, i, open * math.exp((i + 1) * (avg_log_return + factor * log_normal_deviation)))
array.set(lower_std_dev_prices, i, open * math.exp((i + 1) * (avg_log_return - factor * log_normal_deviation)))
// Modified draw_lines function to handle array input correctly
draw_lines(values, line_color) =>
lines = array.new<line>(array.size(values) - 1)
if barstate.islast
for i = 0 to array.size(values) - 2
array.push(lines, line.new(bar_index + i, array.get(values, i), bar_index + i + 1, array.get(values, i + 1), width = 2, color=line_color))
if barstate.isconfirmed
for i = 0 to array.size(lines) - 1
line.delete(array.get(lines, i))
draw_lines(future_prices, color.green)
draw_lines(upper_std_dev_prices, color.red)
draw_lines(lower_std_dev_prices, color.red)
|
Donchian Channel Oscillator (DonOsc) | https://www.tradingview.com/script/WpcI9O22-Donchian-Channel-Oscillator-DonOsc/ | eykpunter | https://www.tradingview.com/u/eykpunter/ | 78 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © eykpunter
//@version=5
indicator(title="Donchian Channel Oscillator", shorttitle = "DonOsc", overlay=false)
//inputs
pertttext="Script uses timeframe to set lookback - month and week: 14, day: 21, 4hour and 3hour:28, 1hour and 45min: 35, 15min: 42, 5min and 3min: 49, 1min: 56"
perwish=input.bool(true, "script sets lookback overrides user", tooltip=pertttext)
perfeedback=input.bool(false, "show feedback label about lookback")
look=input.int(21, "user lookback", minval=5, tooltip="when script sets lookback selected script will override user")
smo=input.int(2, title="smoothing", tooltip="use sma[smo] of depicted value", minval=1, maxval=5)
//input colors
cpriceup=input.color(color.blue, "price momentum up", group="river item colors")
cpricedn=input.color(color.rgb(178,40,51,0), "price momentum down", group="river item colors")
cpushup=input.color(color.new(color.lime,20), "low border (price river upper half)", group="channel item colors")
cpushdn=input.color(color.new(color.fuchsia,30), "high border (price river lower half)", group="channel item colors")
cupside=input.color(color.new(color.lime,50), "price river chooses upside of channel", group="channel item colors")
cdnside=input.color(color.new(color.orange,50), "price river chooses downside of channel", group="channel item colors")
cstochup=input.color(color.new(color.aqua, 55), "stochastic price river up", group="river item colors")
cstochdn=input.color(color.rgb(240,64,122, 30), "stochastic price river down", group="river item colors")
criver=input.color(color.new(color.navy,65), "price river banks and surface", group="river item colors")
ccont=input.color(color.new(color.gray,50), "channel contracting", group="channel item colors")
clightup=input.color(color.new(#faec6a, 60), "uptrend highlighter", group="channel item colors")
clightdn=input.color(color.new(#db9758, 60), "downtrend highlighter", group="channel item colors")
cinvisable=input.color(color.new(color.gray, 100), "invisble color", group="channel item colors")
//calculate periods by script if perwish == true
setper= 14 //initialize setper
tf=timeframe.period
setper:= tf=="M"? 14: tf=="W"? 14: tf=="D"? 21: tf=="240"? 28: tf=="180"? 28: tf=="120"? 35: tf=="60"? 35: tf=="45"? 35: tf=="30"? 42: tf=="15"? 42: tf=="5"? 49: tf=="3"? 49: tf=="1"? 56: 10
look:= perwish? setper : look
//properties of Donchian Channel
hb=ta.highest(high,look)
lb=ta.lowest(low,look)
ran=hb-lb
ranperc=ran/hb*100 //average range as percent of high border
//function to calculate position of depicted value in Donchian Channel Oscillator
pos(wrd) =>
perc=ran/100
calc=(wrd-lb)/perc
position=calc>100? 101: calc<0? -1: calc
//end of function, it returns position as percent
//values to be plotted or used
price=pos(ta.sma(close,smo))
barhi=pos(ta.sma(high,smo))
barlo=pos(ta.sma(low,smo))
barmi=pos(ta.sma(hl2,smo))
barra=barhi-barlo
avrh=50+ranperc
avrl=50-ranperc
//situations for choosing colors
prbarh=price>barmi //price is higher than middle of bar
prbarl=price<barmi //price is lower than middle of bar
prmidh=price>50 //price is over middle line of channel
prmidl=price<50 //price is under middle line of channel
prup=price>=price[1] //price is rising
prdn=price<=price[1] //price is falling
bwide=barra>barra[1] //bar range widening
trup=barhi>76.4 //uptrend called when price is over high fib
trdn=barlo<23.6 //downtrend called when price is under low fib
//cwide=ran>ran[1] //channel widening
//cont=ran<ran[1] //channel contracts
exup=hb>hb[1] and prmidh //new high in in uptrend
exdn=lb<lb[1] and prmidl //new low in downtrend
//conup=cont and prmidh //channel contracts in uptrend
//condn=cont and prmidl //channel contracts in downtrend
//feedback table
var table userorscript = table.new(position=position.bottom_left, columns=1, rows=1)
feedbacktext=perwish? "script lookback " +str.tostring(look) : "user lookback " +str.tostring(look)
if perfeedback == true
table.cell(userorscript, row=0, column=0, text=feedbacktext, bgcolor=color.silver)
else if perfeedback == false
table.clear(userorscript, 0, 0, 0, 0)
//plots
hbor= plot(100, "high border", color=prmidl? cpushdn: cinvisable, linewidth=2)
hf= plot(76.4, "high fib", color=prmidl?cpushdn: cinvisable, style=plot.style_line, linewidth = 2)
lf= plot(23.6, "low fib", color= prmidh? cpushup: cinvisable, style=plot.style_line, linewidth = 2)
lbor= plot(0, "low border", color= prmidh? cpushup: cinvisable, linewidth=2)
cp= plot(price, "close price", color=prup? cpriceup: cpricedn, linewidth=3)
bh= plot(barhi, "high river bank", color=criver)
bl= plot(barlo, "low river bank", color=criver)
//fills
fill(lbor,lf, color=exup? cpriceup: na, title="channel width wider bc up")
fill(hbor,hf, color=exdn? cpricedn: na, title="channel width wider bc down")
fill(cp,bl, color=prup? bwide? cpriceup: prbarh? cstochup: criver: criver, title="volatility stochastic and river up")
fill(cp,bh, color=prdn? bwide? cpricedn: prbarl? cstochdn: criver: criver, title="volatility stochastic and river down")
fill(bh,hbor, color=trup? cupside: na, title="in uptrend zone")
fill(bl,lbor, color=trdn? cdnside: na, title="in downtrend zone")
fill(bl,lf,color=prmidh?clightup:na, title="uptrend highlighter")
fill(bh,hf,color=prmidl?clightdn:na, title="downtrend highlighter")
plot(102,color=color.black)
plot(-2,color=color.black) |
Recessions & crises shading (custom dates & stats) | https://www.tradingview.com/script/ueWc5CGd-Recessions-crises-shading-custom-dates-stats/ | haribotagada | https://www.tradingview.com/u/haribotagada/ | 36 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © haribotagada
//@version=5
indicator(title = 'Recessions & crises shading', shorttitle='Recessions', overlay=true)
// https://en.wikipedia.org/wiki/List_of_recessions_in_the_United_States
// https://www.nber.org/research/data/us-business-cycle-expansions-and-contractions
// https://fred.stlouisfed.org/series/USRECDP
recessionsInput = input.text_area('2020-02-01,2020-03-31,COVID-19\n' +
'2007-12-01,2009-05-31,Subprime mortgages\n' +
'2001-03-01,2001-10-30,Dot-com\n' +
'1990-07-01,1991-03-01,Oil shock\n' +
'1981-07-01,1982-11-01,US unemployment\n' +
'1980-01-01,1980-07-01,Volker\n' +
'1973-11-01,1975-03-01,OPEC',
title='Enter each recession/crisis on a new line', tooltip = 'Type comma separated values without spaces:\n<start>,<end>,<name>\nDate format = YYYY-MM-DD', confirm=true)
correctionTypeInput = input.bool(true, 'Measure correction from peak to through. If unticked, uses prices for the provided recession(s) start and end dates')
GRP2= 'Display preferences'
showLabelsInput = input.bool(true, 'Show labels', group = GRP2)
showStatsInput = input.bool(true, 'Show stats', group = GRP2)
colorTheme = input.string('Dark', title='Color theme', options=['Dark', 'Light'], group = GRP2)
headerBkgrColor = switch colorTheme
'Light' => color.new(#8d8d8d,80)
'Dark' => color.new(#1E232E,0)
headerTxtColor = switch colorTheme
'Light' => color.new(#000000, 0)
'Dark' => color.new(#5f6266, 0)
cellBkgrColor = switch colorTheme
'Light' => color.new(#ffffff, 0)
'Dark' => color.new(color.gray,80)
recessionColor = switch colorTheme
'Light' => color.new(#d0cccc, 0)
'Dark' => color.new(#8d8d8d,80)
textColor = switch colorTheme
'Light' => color.new(#000000, 0)
'Dark' => color.new(#ffffff,60)
statsPositionInput = input.string('Top right', 'Stats position', options=['Bottom left', 'Top center', 'Bottom center', 'Bottom right', 'Top left', 'Top right'], group = GRP2)
statsPosition = switch statsPositionInput
'Top center' => position.top_center
'Bottom center' => position.bottom_center
'Bottom left' => position.bottom_left
'Bottom right' => position.bottom_right
'Top left' => position.top_left
'Top right' => position.top_right
textSizeInput = input.string('Normal', 'Text Size', options=['Auto', 'Tiny', 'Small', 'Normal', 'Large', 'Huge'], group = GRP2)
textSize = switch textSizeInput
'Auto' => size.auto
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal
'Large' => size.large
'Huge' => size.huge
// Helper functions
stringToUnixDate(_date) =>
dataArray = str.split(_date, '-')
yearInput = int(str.tonumber(array.get(dataArray, 0)))
monthInput = int(str.tonumber(array.get(dataArray, 1)))
dayInput = int(str.tonumber(array.get(dataArray, 2)))
timestamp(syminfo.timezone, year = yearInput, month = monthInput, day = dayInput, hour = 0, minute= 0, second=0) // We use int as date inputs and not the raw date string as the timerstamp() function expects a const string if using text input
// Variable declarations
type recession
int start
int end
string name
var recessionsArray = array.new<recession>()
var correctionsArray = array.new_float(na)
var durationsArray = array.new_int(na)
var startBar = 0
var endBar = 0
var startPrice = 0.0
var endPrice = 0.0
var peak = float(na)
var through = float(na)
durationSuffix = timeframe.period
// We only create the recession data array once. No need to recalculate on each bar
if barstate.isfirst
inputArray = str.split(recessionsInput, '\n')
for i=0 to array.size(inputArray) - 1
if array.get(inputArray,i) != ''
info = str.split(array.get(inputArray,i), ',')
startDate = stringToUnixDate(array.get(info,0))
endDate = stringToUnixDate(array.get(info,1))
recessionLabel = array.get(info,2)
array.push(recessionsArray, recession.new(startDate, endDate, recessionLabel))
// On each bar, check if within the provided recession dates.
isRecession = false
var recessionIndex = 0
for i=0 to array.size(recessionsArray) - 1
if time >= array.get(recessionsArray,i).start and time <= array.get(recessionsArray,i).end
recessionIndex := i
isRecession := true
// Code block which runs at the start bar of a new recession
if not isRecession[1] and isRecession
startBar := bar_index
startPrice := close
// initialise peak & thru values using price at start of recession
peak := close
through := close
// Code block that runs if the bar is within a recession
if isRecession
if high > peak
peak := high
if low < through
through := low
// Code block to gather info at end of recession and display label
if isRecession[1] and not isRecession
endBar := bar_index
endPrice := close
duration = endBar - startBar
middle = startBar + int((duration) / 2)
peakToThrough = 100 * (through - peak) / peak
startToEndChg = 100 * (endPrice - startPrice) / startPrice
correction = correctionTypeInput ? peakToThrough : startToEndChg
if showLabelsInput
recessionLabel = array.get(recessionsArray, recessionIndex).name + '\n' +
str.format('{0,number,#.#}%', correction) + '\n' +
str.tostring(duration) + durationSuffix
label.new(x=middle, y=through, text=recessionLabel, style = label.style_label_up, color = color.new(#ffffff,100), textcolor= textColor, size=textSize)
// Save correction and duration info to calculate stats
if showStatsInput
array.push(correctionsArray, correction)
array.push(durationsArray, duration)
// Add shading if bar is within a recession
bgcolor(isRecession ? recessionColor : na)
// display stats
var table stats= table.new(statsPosition, 2, 2, border_width = 1)
if barstate.islast and showStatsInput
if array.size(correctionsArray) > 0 and array.size(durationsArray) > 0
table.cell(stats, 0, 0, 'Avg correction', text_size=textSize, bgcolor=headerBkgrColor, text_color=headerTxtColor)
table.cell(stats, 0, 1, 'Avg duration', text_size=textSize, bgcolor=headerBkgrColor, text_color=headerTxtColor)
table.cell(stats, 1, 0, str.format('{0,number,#.#}%',array.avg(correctionsArray)), text_size=textSize, bgcolor=cellBkgrColor, text_color=textColor)
table.cell(stats, 1, 1, str.format('{0,number,#.#} ',array.avg(durationsArray)) + durationSuffix, text_size=textSize, bgcolor=cellBkgrColor, text_color=textColor) |
Volume Profile Matrix [LuxAlgo] | https://www.tradingview.com/script/y4plLaDG-Volume-Profile-Matrix-LuxAlgo/ | LuxAlgo | https://www.tradingview.com/u/LuxAlgo/ | 1,754 | study | 5 | CC-BY-NC-SA-4.0 | // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo
//@version=5
indicator("Volume Profile Matrix [LuxAlgo]", overlay = true, max_boxes_count = 500, max_lines_count = 500)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length = input.int(200, 'Lookback', minval = 1)
columns = input.int(20, minval = 2)
rows = input.int(20, minval = 2)
//Colors
showAreas = input.bool(true, 'Areas' , inline = 'Gradient', group = 'Style')
lowCss = input.color(color.new(#0a0032, 50), '' , inline = 'Gradient', group = 'Style')
highCss = input.color(color.new(#ff1100, 50), '' , inline = 'Gradient', group = 'Style')
topCss = input.color(color.new(#ffe400, 50), '' , inline = 'Gradient', group = 'Style')
showPoc = input.bool(true, 'Column POC', inline = 'poc', group = 'Style')
pocCss = input.color(color.white, '', inline = 'poc', group = 'Style')
showAxis = input.bool(true, 'Axis', inline = 'axis', group = 'Style')
axisCss = input(#ff5d00, '' , inline = 'axis', group = 'Style')
//-----------------------------------------------------------------------------}
//Main variables
//-----------------------------------------------------------------------------{
var poc_css = color.rgb(color.r(topCss), color.g(topCss), color.b(topCss))
n = bar_index
upper = ta.highest(length)
lower = ta.lowest(length)
var dist = length / columns
var pocs = array.new<line>(0)
mt = matrix.new<float>(rows, columns, 0)
if barstate.isfirst and showPoc
for i = 0 to columns-1
pocs.unshift(line.new(na,na,na,na,color = pocCss))
//-----------------------------------------------------------------------------}
//Display volume matrix
//-----------------------------------------------------------------------------{
var horizontal = line.new(na, na, na, na, color = axisCss)
var vertical = line.new(na, na, na, na, color = axisCss)
for bx in box.all
bx.delete()
if barstate.islast
poc = line.new(na,na,na,na)
x1 = n - length + 1
x2 = n + 1
//Loop trough most recent bars and accumulate volume on corresponding matrix entry
for i = 0 to length-1
col = math.ceil(i / (length-1) * columns)
rh = math.ceil((high[i] - lower)/(upper - lower) * rows)
rl = math.ceil((low[i] - lower)/(upper - lower) * rows)
//Loop trough rows where price is lying on the corresponding column and accumulate volume
for j = math.max(rl-1, 0) to math.max(rh-1, 0)
get_val = mt.get(j, math.max(col-1, 0))
mt.set(j, math.max(col-1, 0), get_val + volume[i])
//Get matrix maximum/minimum
max = mt.max()
min = mt.min()
get_val = 0.
//Loop trough columns
for i = 0 to columns-1
up = upper
dn = upper
get_col_max = mt.col(i).max()
//Loop trough rows
for j = 0 to rows-1
get_val := mt.get(rows-1 - j, i)
//Color gradient
css1 = color.from_gradient(get_val, 0, .8 * max + .1 * min, lowCss, highCss)
css2 = color.from_gradient(get_val, .8 * max + .1 * min, max, css1, topCss)
dn -= (upper - lower) / rows
//Set POC
if get_val == get_col_max and showPoc
avg = math.avg(up, dn)
get_l = pocs.get(i)
get_l.set_xy1(n + 1 - dist * (i + 1), avg)
get_l.set_xy2(n + 1 - dist * i, avg)
if get_val == max
poc := get_l
poc.set_x2(n)
poc.set_color(poc_css)
//Set Box
if get_val != 0 and showAreas
box.new(n + 1 - dist * (i + 1), up, n + 1 - dist * i, dn, na
, bgcolor = css2)
up := dn
//Set Axis
if showAxis
horizontal.set_xy1(n - length + 1, lower)
horizontal.set_xy2(n + 1, lower)
vertical.set_xy1(n - length + 1, upper)
vertical.set_xy2(n - length + 1, lower)
//-----------------------------------------------------------------------------} |
Turtle trading | https://www.tradingview.com/script/K20CzeJ4-Turtle-trading/ | danilogalisteu | https://www.tradingview.com/u/danilogalisteu/ | 44 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © danilogalisteu
//@version=5
indicator("Turtle", overlay=true)
entry_period = input.int(20, "Entry period", minval=2)
exit_period = input.int(10, "Exit period", minval=1)
show_trades = input.bool(false, "Show entries and exits")
show_levels = input.bool(true, "Show levels")
show_labels = input.bool(true, "Show level values")
// price levels
le = ta.highest(high, entry_period)[1]
lx = ta.lowest(low, exit_period)[1]
se = ta.lowest(low, entry_period)[1]
sx = ta.highest(high, exit_period)[1]
// trend
trend_state = 0
trend_state := nz(trend_state[1])
if trend_state[1] < 1 and high > le
trend_state := 1
if trend_state[1] > 0 and low <= lx
trend_state := 0
if trend_state[1] > -1 and low < se
trend_state := -1
if trend_state[1] < 0 and high >= sx
trend_state := 0
trend_active = trend_state != 0
trend_long = trend_state > 0
trend_short = trend_state < 0
// values in data window
plot(trend_state, "Trend", display=display.all-display.pane, color=trend_long?color.green:trend_short?color.red:color.yellow)
plot(le, "Long Entry", display=display.all-display.pane, color=color.green)
plot(lx, "Long Exit", display=display.all-display.pane, color=color.green)
plot(se, "Short Entry", display=display.all-display.pane, color=color.red)
plot(sx, "Short Exit", display=display.all-display.pane, color=color.red)
// price levels
color_long_entry = color.green
color_long_exit = color.aqua
color_short_entry = color.red
color_short_exit = color.yellow
plot(show_levels and trend_long[1] ? lx : na, "STLX", color=color_long_exit, linewidth=1, style=plot.style_linebr, display=display.pane)
plot(show_levels and trend_short[1] ? sx : na, "STSX", color=color_short_exit, linewidth=1, style=plot.style_linebr, display=display.pane)
plot(show_levels and not trend_active[1] ? le : na, "STLE", color=color_long_entry, linewidth=1, style=plot.style_linebr, display=display.pane)
plot(show_levels and not trend_active[1] ? se : na, "STSE", color=color_short_entry, linewidth=1, style=plot.style_linebr, display=display.pane)
// entry / exit points
long_entry = (trend_state > 0) and (trend_state[1] <= 0)
long_exit = (trend_state <= 0) and (trend_state[1] > 0)
short_entry = (trend_state < 0) and (trend_state[1] >= 0)
short_exit = (trend_state >= 0) and (trend_state[1] < 0)
plotshape(show_trades and long_entry ? le : na, style=shape.arrowup, color=color_long_entry, location=location.abovebar, display=display.pane, size=size.normal)
plotshape(show_trades and long_exit ? lx : na, style=shape.diamond, color=color_long_exit, location=location.belowbar, display=display.pane, size=size.small)
plotshape(show_trades and short_entry ? se : na, style=shape.arrowdown, color=color_short_entry, location=location.belowbar, display=display.pane, size=size.normal)
plotshape(show_trades and short_exit ? lx : na, style=shape.diamond, color=color_short_exit, location=location.abovebar, display=display.pane, size=size.small)
// labels
l_le = label(na)
l_se = label(na)
l_lx = label(na)
l_sx = label(na)
if not trend_active[1]
label.delete(l_le[1])
label.delete(l_se[1])
if show_labels
l_le := label.new(bar_index, le, str.tostring(le), yloc=yloc.price, color=color_long_entry, style=label.style_label_lower_right)
l_se := label.new(bar_index, se, str.tostring(se), yloc=yloc.price, color=color_short_entry, style=label.style_label_upper_right)
else
label.delete(l_lx[1])
label.delete(l_sx[1])
if show_labels
if trend_long[1]
l_lx := label.new(bar_index, lx, str.tostring(lx), yloc=yloc.price, color=color_long_exit, style=label.style_label_upper_left)
if trend_short[1]
l_sx := label.new(bar_index, sx, str.tostring(sx), yloc=yloc.price, color=color_short_exit, style=label.style_label_lower_left)
|
Relative Volume | https://www.tradingview.com/script/H7suYM5K-Relative-Volume/ | starstudded | https://www.tradingview.com/u/starstudded/ | 133 | study | 4 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © starstudded
//@version=4
study("Relative Volume", shorttitle="RVOL", format=format.volume)
lsmalength = input(50, "LSMA Length", group="General Settings")
std = 21
ma2 = linreg(volume, lsmalength, 0)
stdev_volume = stdev(volume, std)
clean = volume - ma2
showanom = input(true, "Show Anomalies")
len = input(50, "Length")
threshold_multiplier = input(2, "Threshold Multiplier", minval=0.1, maxval=20)
avg_volume = sma(volume, len)
rvol = volume / avg_volume
// Plotting the threshold line based on the threshold multiplier
threshold_line = threshold_multiplier
plot(threshold_line, "Threshold", color=color.rgb(124, 124, 124))
// Normalize volume and anomalies
normalized_volume = volume / avg_volume
normalized_anomalies = clean / avg_volume
// Plotting the normalized volume
plot(normalized_volume, style=plot.style_columns, color=close > open ? color.rgb(101, 101, 101) : color.rgb(50, 50, 50), title="Normalized Volume", trackprice=false)
// Determine the color of anomalies
anomaly_color = close > open ? color.blue : color.red
// Plotting the normalized anomalies
plot(showanom and normalized_anomalies > stdev_volume / avg_volume ? normalized_volume : na, style=plot.style_columns, color=anomaly_color, title="Normalized Anomalies")
// Alert condition
cross_above_threshold = crossover(normalized_anomalies, threshold_line)
alertcondition(cross_above_threshold, title="Candle Crossed Threshold", message="A candle has crossed the threshold.")
// ------------------------------- Candle colour ------------------------------------------------------------
// inputs
i_src = input("Volume", title="Source", type=input.string)
lenCan = input(20, "Z-Score MA Length")
z1 = input(2.0, "Threshold z1", step=0.1)
z2 = input(2.9, "Threshold z2", step=0.1)
low_volume_threshold = input(-0.9, "Low Volume Threshold", step=0.1)
// functions
f_zscore(src, lenCan) =>
mean = sma(src, lenCan)
std = stdev(src, lenCan)
z = (src - mean) / std
// calculations
z_volume = f_zscore(volume, lenCan)
z_body = f_zscore(abs(close - open), lenCan)
float z = na
if i_src == "Volume"
z := z_volume
else if i_src == "Body size"
z := z_body
else if i_src == "Any"
z := max(z_volume, z_body)
else if i_src == "All"
z := min(z_volume, z_body)
normal = z < z1
large = z >= z1 and z < z2
extreme = z >= z2
up = close >= open
down = close < open
low_volume = z_volume < low_volume_threshold
up_normal = up and normal
up_large = up and large
up_extreme = up and extreme
down_normal = down and normal
down_large = down and large
down_extreme = down and extreme
// plots
color_up = up_extreme ? color.rgb(0, 255, 8) : up_large ? color.blue : up_normal ? color.rgb(222, 222, 222) : na
color_down = down_extreme ? color.rgb(199, 22, 193) : down_large ? color.rgb(224, 75, 75) : down_normal ? color.rgb(0, 0, 0) : na
barcolor((up_normal or up_large or up_extreme) and not low_volume ? color_up : low_volume ? color.yellow : na, title="Up Bar")
barcolor((down_normal or down_large or down_extreme) and not low_volume ? color_down : low_volume ? color.yellow : na, title="Down Bar") |
Chebyshev type I and II Filter | https://www.tradingview.com/script/wn1YfGVm-Chebyshev-type-I-and-II-Filter/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 20 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Chebyshev type I and II", "CHBV", true)
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, int len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
// Chebyshev Type II Moving Average
chebyshevII(float src, int len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / ripple))
b := sinh(1 / len * asinh(ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1], src)
chebyshev
// adjust the ripple value based on your requirement (between 0 and 1)
chebyshev(float src, int length, float ripple, bool style) =>
not style ?
chebyshevI(src, length, ripple) :
chebyshevII(src, length, ripple)
source = input.source(close, "Source")
length = input.int(14, 'Length', 2, 5000)
ripple = input.float(0.05, "Ripple", 0.01, 1, 0.01)
style = input.bool(false, "Use type II")
cheb = chebyshev(source, length, ripple, style)
plot(cheb, "Chebyshev Type Moving Average", color.orange, 2)
|
Stochastic Chebyshev Smoothed With Zero Lag Smoothing | https://www.tradingview.com/script/Mk1iVaf2-Stochastic-Chebyshev-Smoothed-With-Zero-Lag-Smoothing/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 67 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Stochastic Chebyshev Smoothed With 0 Lag Smoothing", "CSTOCH")
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Function to calculate the Gaussian weight for a given 'k' and 'smooth_per'
gaussian_weight(k, smooth_per) =>
// Calculate the standard deviation (sigma) based on the smoothing period
sigma = smooth_per / 2.0
// Calculate the exponent part of the Gaussian function
exponent = -0.5 * math.pow(k / sigma, 2)
// Calculate and return the Gaussian weight
math.exp(exponent)
// Function to calculate the zero-lag moving average with Gaussian weights
zero_lag_gwma(src, smooth_per) =>
// Declare and initialize the source buffer, sum, sumw, and weight variables
var float[] src_buffer = array.new_float(0, na)
var sum = 0.0
var sumw = 0.0
var weight = 0.0
// Declare and initialize the gwma1 and output arrays
var float[] gwma1 = array.new_float(smooth_per, na)
var float[] output = array.new_float(smooth_per, na)
// Update the source buffer with the new value
array.push(src_buffer, src)
// Remove the oldest element when the buffer size reaches smooth_per
if array.size(src_buffer) > smooth_per
array.shift(src_buffer)
// Calculate the current buffer size
buffer_size = array.size(src_buffer)
// Calculate the first Gaussian weighted moving average (gwma1) with Gaussian weights
for i = 0 to buffer_size - 1
// Reset sum and sumw for each iteration
sum := 0.0
sumw := 0.0
for k = 0 to smooth_per - 1
// Check if the index is within the buffer size
if i + k < buffer_size
// Calculate the Gaussian weight for the current 'k'
weight := gaussian_weight(k, smooth_per)
// Update the sum of weights
sumw += weight
// Update the sum of weighted source values
sum += weight * array.get(src_buffer, i + k)
// Calculate and set the gwma1 value for the current index
if sumw != 0
array.set(gwma1, i, sum / sumw)
else
array.set(gwma1, i, na)
// Calculate the final zero-lag moving average (output) with Gaussian weights
for i = 0 to buffer_size - 1
// Reset sum and sumw for each iteration
sum := 0.0
sumw := 0.0
for k = 0 to smooth_per - 1
// Check if the index is within the buffer size
if i - k >= 0
// Calculate the Gaussian weight for the current 'k'
weight := gaussian_weight(k, smooth_per)
// Update the sum of weights
sumw += weight
// Update the sum of weighted gwma1 values
sum += weight * array.get(gwma1, i - k)
// Calculate and set the output value for the current index
if sumw != 0
array.set(output, i, sum / sumw)
else
array.set(output, i, na)
// Return the most recent moving average value
array.get(output, buffer_size - 1)
// Chebyshev Type I Moving Average
chebyshevI(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
length = input.int(14, "Stochastic Length", 1)
k_smoothing = input.int(14, "K Chebyshev Filtering", 5)
k_ripple = input.float(0.05, "K Chebyshev Ripple", 0.01, 0.99, 0.01)
k_extra = input.int(1, "K Zero Lag Smoothing", 1)
d_smoothing = input.int(20, "D Chebyshev Filtering", 5)
d_ripple = input.float(0.01, "D Chebyshev Ripple", 0.01, 0.99, 0.01)
stoch = zero_lag_gwma(ta.stoch(chebyshevI(close, k_smoothing, k_ripple), chebyshevI(high, k_smoothing, k_ripple), chebyshevI(low, k_smoothing, k_ripple), length), k_extra)
lag = chebyshevI(stoch, d_smoothing, d_ripple)
plot(stoch, color = #2962FF)
plot(lag, color = #FF6D00)
h0 = hline(80, "Upper Band", color=#787B86)
hline(50, "Middle Band", color=color.new(#787B86, 50))
h1 = hline(20, "Lower Band", color=#787B86)
fill(h0, h1, color=color.rgb(33, 150, 243, 90), title="Background") |
Multi Time Frame Normalized Price | https://www.tradingview.com/script/jirgeUd6-Multi-Time-Frame-Normalized-Price/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 21 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Multi Time Frame Normalized Price", "MTFNP", false, max_lines_count = 500)
import peacefulLizard50262/Spider_Plot/2 as s
length = input.int(20, "STDEV LENGTH", 1)
multiplier = input.float(1, "STDEV MULTIPLIER")
axes_color = input.color(color.new(color.gray, 90), "Axes Color")
bottom_color = input.color(color.new(color.red, 10) , "Bottom Color")
top_color = input.color(color.new(color.blue, 10), "Top Color")
xpos = input.float(2, "X Position")
ypos = input.float(0, "Y Position")
scale = input.float(30, "Scale")
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
normalizedPrice(int length, float multiplier) =>
upper = chebyshevI(high, 62, 0.01)
lower = chebyshevI(low, 62, 0.01)
mean = math.avg(upper, lower)
stdev = math.sqrt(math.sum(math.pow(close - mean, 2), length) / length - 1)
price = chebyshevI(close, 26, 0.01) - mean
bot = lower - mean - stdev * multiplier
top = upper - mean + stdev * multiplier
normalized = (price - bot) / (top - bot)
math.max(math.min(nz(normalized, nz(normalized[1])), 1), 0)
time_1 = normalizedPrice(length, multiplier)
time_2 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 2)), normalizedPrice(length, multiplier))
time_3 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 3)), normalizedPrice(length, multiplier))
time_4 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 4)), normalizedPrice(length, multiplier))
time_5 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 5)), normalizedPrice(length, multiplier))
time_6 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 6)), normalizedPrice(length, multiplier))
time_7 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 7)), normalizedPrice(length, multiplier))
time_8 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 8)), normalizedPrice(length, multiplier))
time_9 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 9)), normalizedPrice(length, multiplier))
time_10 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 10)), normalizedPrice(length, multiplier))
time_11 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 11)), normalizedPrice(length, multiplier))
time_12 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 12)), normalizedPrice(length, multiplier))
time_13 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 13)), normalizedPrice(length, multiplier))
time_14 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 14)), normalizedPrice(length, multiplier))
time_15 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 15)), normalizedPrice(length, multiplier))
time_16 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 16)), normalizedPrice(length, multiplier))
time_17 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 17)), normalizedPrice(length, multiplier))
time_18 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 18)), normalizedPrice(length, multiplier))
time_19 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 19)), normalizedPrice(length, multiplier))
time_20 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 20)), normalizedPrice(length, multiplier))
time_21 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 21)), normalizedPrice(length, multiplier))
time_22 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 22)), normalizedPrice(length, multiplier))
time_23 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 23)), normalizedPrice(length, multiplier))
time_24 = request.security(syminfo.tickerid, str.tostring(int(str.tonumber(timeframe.period) * 24)), normalizedPrice(length, multiplier))
color_1 = color.from_gradient(time_1, 0, 1, bottom_color, top_color)
color_2 = color.from_gradient(time_2, 0, 1, bottom_color, top_color)
color_3 = color.from_gradient(time_3, 0, 1, bottom_color, top_color)
color_4 = color.from_gradient(time_4, 0, 1, bottom_color, top_color)
color_5 = color.from_gradient(time_5, 0, 1, bottom_color, top_color)
color_6 = color.from_gradient(time_6, 0, 1, bottom_color, top_color)
color_7 = color.from_gradient(time_7, 0, 1, bottom_color, top_color)
color_8 = color.from_gradient(time_8, 0, 1, bottom_color, top_color)
color_9 = color.from_gradient(time_9, 0, 1, bottom_color, top_color)
color_10 = color.from_gradient(time_10, 0, 1, bottom_color, top_color)
color_11 = color.from_gradient(time_11, 0, 1, bottom_color, top_color)
color_12 = color.from_gradient(time_12, 0, 1, bottom_color, top_color)
color_13 = color.from_gradient(time_13, 0, 1, bottom_color, top_color)
color_14 = color.from_gradient(time_14, 0, 1, bottom_color, top_color)
color_15 = color.from_gradient(time_15, 0, 1, bottom_color, top_color)
color_16 = color.from_gradient(time_16, 0, 1, bottom_color, top_color)
color_17 = color.from_gradient(time_17, 0, 1, bottom_color, top_color)
color_18 = color.from_gradient(time_18, 0, 1, bottom_color, top_color)
color_19 = color.from_gradient(time_19, 0, 1, bottom_color, top_color)
color_20 = color.from_gradient(time_20, 0, 1, bottom_color, top_color)
color_21 = color.from_gradient(time_21, 0, 1, bottom_color, top_color)
color_22 = color.from_gradient(time_22, 0, 1, bottom_color, top_color)
color_23 = color.from_gradient(time_23, 0, 1, bottom_color, top_color)
color_24 = color.from_gradient(time_24, 0, 1, bottom_color, top_color)
data = array.from(
time_1
, time_2
, time_3
, time_4
, time_5
, time_6
, time_7
, time_8
, time_9
, time_10
, time_11
, time_12
, time_13
, time_14
, time_15
, time_16
, time_17
, time_18
, time_19
, time_20
, time_21
, time_22
, time_23
, time_24
, time_23
, time_22
, time_21
, time_20
, time_19
, time_18
, time_17
, time_16
, time_15
, time_14
, time_13
, time_12
, time_11
, time_10
, time_9
, time_8
, time_7
, time_6
, time_5
, time_4
, time_3
, time_2
)
color_data = array.from(
color_1
, color_2
, color_3
, color_4
, color_5
, color_6
, color_7
, color_8
, color_9
, color_10
, color_11
, color_12
, color_13
, color_14
, color_15
, color_16
, color_17
, color_18
, color_19
, color_20
, color_21
, color_22
, color_23
, color_24
, color_23
, color_22
, color_21
, color_20
, color_19
, color_18
, color_17
, color_16
, color_15
, color_14
, color_13
, color_12
, color_11
, color_10
, color_9
, color_8
, color_7
, color_6
, color_5
, color_4
, color_3
, color_2
)
s.draw_spider_plot(data, color_data, axes_color, scale, xpos, ypos)
|
SuperTrend with Chebyshev Filter | https://www.tradingview.com/script/nsjNg8mF-SuperTrend-with-Chebyshev-Filter/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 226 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Chebyshev Trend", overlay = true, max_labels_count = 500)
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
// Chebyshev Type II Moving Average
chebyshevII(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / ripple))
b := sinh(1 / len * asinh(ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1], src)
chebyshev
chebyshev(float src, float length, float ripple, bool style) =>
style ?
chebyshevI(src, length, ripple) :
chebyshevII(src, length, ripple)
source = input.source(hl2, "Source")
up_color = input.color(color.new(color.green, 20), "Up Color")
down_color = input.color(color.new(color.red, 20), "Down Color")
text_color = input.color(color.black, "Text Color")
mean_length = input.float(64, "Mean Length", 5, 1000, 0.5)
mean_ripple = input.float(0.2, "Mean Ripple", 0.01, 0.99, 0.01)
style = input.bool(false, "True Chebyshev I | False : Chebyshev II")
atr_style = input.bool(false, "True: |Open-Close| False: High-Low")
atr_length = input.float(64, "ATR Length", 6, 1000, 0.5)
atr_ripple = input.float(0.05, "Mean Ripple", 0.01, 0.99, 0.01)
multiplier = input.float(1.5, "Multiplier", 0.125, 10, 0.125)
alerts = input.bool(false, "Alerts")
labels = input.bool(false, "Labels")
atr = chebyshev(atr_style ? high - low : math.abs(open - close), atr_length, atr_ripple, style)
mean = chebyshevI(source, mean_length, mean_ripple)
var float offset = 0.0
var bool state = na
var float newOffset = 0.0
crossover = ta.crossover(source, offset)
position = source > offset
crossunder = ta.crossunder(source, offset)
prevOffset = nz(offset[1])
if crossover[2] and position[1] and position or (position and position[1] and position[2])
newOffset := mean - atr * multiplier
offset := newOffset < nz(prevOffset) or close[1] > nz(prevOffset) ? newOffset : nz(prevOffset)
state := true
if crossunder[2] and not position[1] and not position or (not position and not position[1] and not position[2])
newOffset := mean + atr * multiplier
offset := newOffset > nz(prevOffset) or close[1] < nz(prevOffset) ? newOffset : nz(prevOffset)
state := false
cross = ta.cross(close, offset)
down_trend = not state and not state[1]
up_trend = state and state[1]
colour = up_trend ? up_color : down_trend ? down_color : color.new(color.white, 100)
if up_trend and not up_trend[1] and labels
label.new(bar_index, offset, "Up Trend \n" + str.tostring(close), color = up_color, style = label.style_label_up, textcolor = text_color)
alert("Up Trend at " + str.tostring(close))
else
alert("Up Trend at " + str.tostring(close))
if down_trend and not down_trend[1] and labels
label.new(bar_index, offset, "Down Trend \n" + str.tostring(close), color = down_color, style = label.style_label_down, textcolor = text_color)
alert("Down Trend at " + str.tostring(close))
else
alert("Down Trend at " + str.tostring(close))
plot(offset, "Chebyshev Trend", colour, style = plot.style_linebr)
plotshape(cross, "Trend Is Getting Ready To Change", shape.xcross, location.belowbar, color = close > offset ? up_color : down_color) |
MACD Chebyshev (CMACD) | https://www.tradingview.com/script/QLFPDWZg-MACD-Chebyshev-CMACD/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 72 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("MACD Chebyshev (CMACD)", "CMACD", false)
import lastguru/DominantCycle/2 as d
j(source, delay)=>
3 * source-2 * delay
diff(src, N) =>
switch N
1 => src - src[1]
2 => (src - src[2]) / 2
3 => (src + src[1] - src[2] - src[3]) / 4
4 => (src + 2 * src[1] - 2 * src[3] - src[4]) / 8
5 => (src + 3 * src[1] + 2 * src[2] - 2 * src[3] - 3 * src[4] - src[5]) / 16
6 => (src + 4 * src[1] + 5 * src[2] - 5 * src[4] - 4 * src[5] - src[6]) / 32
7 => (src + 5 * src[1] + 9 * src[2] + 5 * src[3] - 5 * src[4] - 9 * src[5] - 5 * src[6] - src[7]) / 64
8 => (src + 6 * src[1] + 14 * src[2] + 14 * src[3] - 14 * src[5] - 14 * src[6] - 6 * src[7] - src[8]) / 128
9 => (src + 7 * src[1] + 20 * src[2] + 28 * src[3] + 14 * src[4] - 14 * src[5] - 28 * src[6] - 20 * src[7] - 7 * src[8] - src[9]) / 256
10 => (src + 8 * src[1] + 27 * src[2] + 48 * src[3] + 42 * src[4] - 42 * src[6] - 48 * src[7] - 27 * src[8] - 8 * src[9] - src[10]) / 512
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
// Chebyshev Type II Moving Average
chebyshevII(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / ripple))
b := sinh(1 / len * asinh(ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1], src)
chebyshev
noise_gate(signal, ratio, level, knee_type) =>
// Calculate the absolute value of the signal
abs_signal = math.abs(signal)
// Check the value of the knee_type parameter
if knee_type == "hard"
// If the knee_type is "hard", apply a hard knee
if abs_signal > level
out = signal
else
out = signal / ratio
else
// If the knee_type is not "hard", apply a soft knee
if (abs_signal > level) or level == 0
// If the absolute value is above the threshold, return the signal as is
out = signal
else
// If the absolute value is below the threshold, calculate the soft knee ratio
soft_knee_ratio = 1 - (level - abs_signal) / level
// Reduce the amplitude of the signal by the soft knee ratio
out = signal * soft_knee_ratio
// adjust the ripple value based on your requirement (between 0 and 1)
chebyshev(float src, float length, float ripple, bool style) =>
not style ?
chebyshevI(src, length, ripple) :
chebyshevII(src, length, ripple)
source = input.source(close)
length_diff = input.int(1, "Slow Line Delay", 1, 10)
ripple = input.float(0.3, "Ripple", 0.01, 1, 0.01)
gate_level = input.int(25, "Percent Rank for the gate signal level", 0, 100)
gate_length = input.int(100, "Percent Rank Length", 10)
gate_ratio = input.int(100, "Gate Ratio")
enable_j = input.bool(false, "Enable KDJ Style J Line")
length = d.mamaPeriod(source, 8, 2048)
knee_type = "hard"
col_grow_above = input(#26a69a, "Above Grow", group="Histogram", inline="Above")
col_fall_above = input(#B2DFDB, "Fall", group="Histogram", inline="Above")
col_grow_below = input(#FFCDD2, "Below Grow", group="Histogram", inline="Below")
col_fall_below = input(#ef5350, "Fall", group="Histogram", inline="Below")
cheb = chebyshev(source - chebyshev(source, length, 0.3, false), length, ripple, true)
delay = cheb[length_diff]
macd = diff(cheb, length_diff)
level = ta.percentile_nearest_rank(math.abs(macd), gate_length, gate_level)
hist = noise_gate(macd, gate_ratio, level, knee_type)
j_line = j(cheb, delay)
colour = hist >= 0 ? (hist[1] < hist ? col_grow_above : col_fall_above) : (hist[1] < hist ? col_grow_below : col_fall_below)
plot(cheb, "Fast", color.blue, 1)
plot(delay, "Slow", color.orange, 1)
plot(hist, "Histogram", colour, style = plot.style_columns)
plot(enable_j ? j_line : na, "J Line", color.purple)
plot(0, color = color.gray)
|
4 Pole Butterworth | https://www.tradingview.com/script/5Y3LACs1-4-Pole-Butterworth/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 17 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("4 Pole Butterworth", "4PB", true)
fourpolebutter(float src, int len) =>
a1 = 0.
b1 = 0.
c1 = 0.
coef1 = 0.
coef2 = 0.
coef3 = 0.
coef4 = 0.
coef5 = 0.
bttr = 0.
trig = 0.
a1 := math.exp(-0.5 * math.pi / len)
b1 := 2.0 * a1 * math.cos(0.5 * math.pi / len)
c1 := a1 * a1
coef2 := b1 + c1
coef3 := -(c1 + b1 * c1)
coef4 := c1 * c1
coef5 := (1 - b1 + c1) * (1 - c1) / 16
bttr := coef5 * (src + 4 * nz(src[1]) + 6 * nz(src[2]) + 4 * nz(src[3]) + nz(src[4])) + coef2 * nz(bttr[1]) + coef3 * nz(bttr[2]) + coef4 * nz(bttr[3])
bttr := bar_index < 5 ? src : bttr
bttr
source = input.source(close, "Source")
length = input.int(14, "length", 5)
fourpolebutter = fourpolebutter(source, length)
plot(fourpolebutter, "Four Pole Butterworth")
|
Tape (Time and Sales) | https://www.tradingview.com/script/vIDMwYuU-Tape-Time-and-Sales/ | liquid-trader | https://www.tradingview.com/u/liquid-trader/ | 495 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © liquid-trader
// This indicator is a synthesized "Tape" (aka. Time and Sales) from real time market data.
// It's specifically designed to be performant, expediting trading insights and decisions.
// More here: https://www.tradingview.com/script/vIDMwYuU-Tape-Time-and-Sales/
//@version=5
indicator("Tape (Time and Sales)", "Tape", true, max_bars_back=0)
// Base Colors
none = color.new(color.black, 100), clr1 = color.lime, clr2 = color.red, clr3 = color.yellow, clr4 = color.white, clr5 = color.silver, clr6 = color.black, clr7 = color.rgb(0,0,0,0)
// Time & Sales Settings
g1 ="Time and Sales", i1 = "Text Color of Cell", i2 = "Background Color of Cell", act1 = "Non Premium (Basic, Essential, Plus)", act2 = "Premium"
acct = input.string(act1, "Account Type", [act1, act2], "The print frequency and precision relies on chart updates. The most granular data non Premium users have access to is a 1 minute chart, which tends to update about once every second. This update interval can aggregate volume changes into a single print rather than showing each volume change as a unique print.\n\nPremium accounts have access to sub-minute timeframe data, which can update intra-second. This means chart update intervals better align with volume changes, lending itself to more frequent and precise prints.\n\nIf you select \"Premium\" and do not in fact have a Premium account, the script may break when it tries to request data the account type does not have access to.", group=g1, display=display.none)
tlen = input.int(20,"Tape Length", 1, 100, 1,tooltip="The max number of \"Time and Sale\" rows displayed in the table.", group=g1, display=display.none)
prsn = input.int(0, "Size Precision",0, 10, 1, tooltip="How many digits passed the decimal you would like to see, if volume is not a whole number.", group=g1, display=display.none)
min = input.float(0.000001, "Min Print Size", 0, step=1, tooltip="The smallest volume size you want to see.", group=g1, display=display.none)
lrg = input.float(1000, "Large Size Min", 1, step=100, tooltip="A single order volume size considered to be large for this security.", group=g1, display=display.none)
hlt = input.bool(true, "Highlight large prints","Changes the colors of a rows \"Size\" cell if it meets the \"Large Size Min\" threshold.", group=g1, display=display.none)
big = input.bool(true, "Increase row height of large prints", "Enlarges the vertical height of a row if the \"Size\" cell meets the \"Large Size Min\" threshold.", group=g1, display=display.none)
pUpt = input.color(clr7, "Bull", inline=i1, group=g1, display=display.none)
pDnt = input.color(clr7, "Bear", inline=i1, group=g1, display=display.none)
lSzt = input.color(clr7, "Large", inline=i1, group=g1, display=display.none)
hdrt = input.color(clr4, "Header", inline=i1, group=g1, display=display.none)
deft = input.color(clr5, "Default", "Text Colors", inline=i1, group=g1, display=display.none)
pUpc = input.color(clr1, "Bull ", inline=i2, group=g1, display=display.none)
pDnc = input.color(clr2, "Bear", inline=i2, group=g1, display=display.none)
lSzc = input.color(clr3, "Large", inline=i2, group=g1, display=display.none)
hdrc = input.color(clr6, "Header", inline=i2, group=g1, display=display.none)
defc = input.color(clr6, "Default", "Cell / Row Colors", inline=i2, group=g1, display=display.none)
// Volume Metrics Settings
g2 = "Bar Volume Metrics"
vmPrsn = input.int(2, "Metric Precision", 0, 10, 1, tooltip="How many digits passed the decimal you would like to see, if the metric is not a whole number.", group=g2, display=display.none)
vmUp = input.bool(false, "↑ Up ", "Total bar volume correlated with rising prices, and the value at which to highlight the metric.", "up", g2, display=display.none)
vmDn = input.bool(false, "↓ Down ", "Total bar volume correlated with falling prices, and the value at which to highlight the metric.", "down", g2, display=display.none)
vmSok = input.bool(false, "→ Absorbed ", "Total bar volume correlated with unchanging prices, and the value at which to highlight the metric. The volume absorbed by at a given price.", "absorb", g2, display=display.none)
vmTot = input.bool(false, "+ Total ", "Sum of all bar volume, and the value at which to highlight the metric.", "total", g2, display=display.none)
vmRto = input.bool(false, "% Ratio ", "The ratio between up and down bar volume, and the value at which to highlight the metric. \"Up\" is the numerator in positive ratios and \"Down\" is the numerator in negative ratios. \"Absorbed\" is added to the denominator of both positive and negative ratios.", "ratio", g2, display=display.none)
vmMov = input.bool(false, "⇅ Move ", "Bar volume of a continuous directional move, excluding \"absorbed\", and the value at which to highlight the metric.", "move", g2, display=display.none)
vmAcc = input.bool(false, "☳ Accumulation ", "Bar volume accumulating at the current price, and the value at which to highlight the metric. Similar to \"absorbed\", but includes the volume of the last price change.", "accum", g2, display=display.none)
vmUpSig = input.float(1000, "", inline="up", group=g2, display=display.none)
vmDnSig = input.float(1000, "", inline="down", group=g2, display=display.none)
vmSoSig = input.float(1000, "", inline="absorb", group=g2, display=display.none)
vmToSig = input.float(3000, "", inline="total", group=g2, display=display.none)
vmRtSig = input.float(3, "", inline="ratio", group=g2, display=display.none)
vmMoSig = input.float(100, "", inline="move", group=g2, display=display.none)
vmAcSig = input.float(100, "", inline="accum", group=g2, display=display.none)
// General Table Settings
g3 = "Table Settings", i3 = "Position", i4 = "Frame", i5 = "Border"
tsiz = input.string(size.auto, "Text Size ", [size.tiny, size.small, size.normal, size.large, size.huge, size.auto],"The size of a cells text.", group=g3, display=display.none)
yPos = input.string("Middle", "Location on the Chart ", ["Top", "Middle", "Bottom"], inline=i3, group=g3, display=display.none)
xPos = input.string("Right", "",["Left", "Center", "Right"], inline=i3, group=g3, display=display.none)
frmw = input.int(0, "Frame Width & Color ", 0, 10, 1, inline=i4, group=g3, display=display.none)
frmc = input.color(none, "", inline=i4, group=g3, display=display.none)
brdw = input.int(1, "Border Width & Color ", 0, 10, 1, inline=i5, group=g3, display=display.none)
brdc = input.color(none, "", inline=i5, group=g3, display=display.none)
shot = input.bool(true, "Time Column ", "The format and time zone of the date / time.\n\nThe date / time format can be any ISO 8601 format, and the time zone can be any IANA time zone ID (ie. \"America/New_York\").\n\nThe default format is \"hh:mm:ss a\" to only show time, and the default time zone is \"syminfo.timezone\", which inherits the time zone of the exchange of the chart.", inline="datetime", group=g3, display=display.none)
frmt = input.string("hh:mm:ss a", "", inline="datetime", group=g3, display=display.none)
zone = input.string("syminfo.timezone", "", inline="datetime", group=g3, display=display.none)
invertTape = input.bool(false, "Invert Tape Direction", "When enabled, metrics will move to the bottom of the tape, the price / size / time column headers will appear beneath the print stream, and the newest prints will be at the bottom of the print stream causing the prints to \"scroll\" up instead of down.", group=g3, display=display.none)
// Ancillary Params
tmzn = zone == "syminfo.timezone" ? syminfo.timezone : zone
vmVis = array.from(vmUp, vmDn, vmSok, vmTot, vmRto, vmMov, vmAcc), vmArr = vmVis.size()
vmSig = array.from(vmUpSig, vmDnSig, vmSoSig, vmToSig, vmRtSig, vmMoSig, vmAcSig)
// Create new arrays for tracking price, volume, and timestamps.
varip price = array.new_float(), varip vol = array.new_float(), varip stamp = array.new_int()
// Initialize core variables.
varip vdiff = array.new_float(2, 0), varip vsize = 0.0, varip newVolume = false, varip prevDir = 0., varip bull = 0., varip bear = 0., varip abso = 0., varip totl = 0., varip move = 0., varip volAtPrice = 0., varip accu = 0., varip rtio = 0., metricOffset = 0
// Get price, volume, and time from a 1 second chart.
tf = acct == act1 ? "1" : "1S"
[ltf_p, ltf_v, ltf_t] = request.security_lower_tf(syminfo.tickerid, tf, [close, volume, timenow])
// Putting the core logic within a single iteration loop reduces performance penalties accumulated over time.
// This is because historical values of variables initialized inside a loop are not maintained.
for Fewer_Performance_Penalties_Over_Time = 0 to 0
// Reset some of the core variables on each new bar.
if barstate.isnew
vdiff.fill(0), bull := 0, bear := 0, abso := 0, totl := 0
// Calc the new volume size.
barVol = ltf_v.sum()
if barVol != vdiff.last()
vdiff.push(barVol), vdiff.shift()
vsize := vdiff.range()
newVolume := true
// Update the price, volume, and timestamp arrays when there is new volume and the minimum print size is reached.
if barstate.isrealtime and newVolume and vsize >= min
price.unshift(ltf_p.last()), vol.unshift(vsize), stamp.unshift(ltf_t.last())
// Create array for column headers, which also serves to define the number of columns.
hdrStr = shot ? array.from(" PRICE ", " SIZE ", " TIME ") : array.from(" PRICE ", " SIZE ")
// Track column and row lengths.
headrArr = hdrStr.size(), priceArr = price.size()
// Create table with params and metric variables / header array.
vmTitles = array.from(" ↑ Up ", " ↓ Down ", " → Abs … ", " + Total ", " % Ratio ", " ⇅ Move ", " ☳ Acc … ")
tape = table.new(str.lower(yPos) + "_" + str.lower(xPos), headrArr, tlen + vmArr + 3, none, frmc, frmw, brdc, brdw)
// If there are at least 2 prices to compare…
if priceArr > 1
// If any metrics are enabled…
if vmVis.includes(true)
// Update metrics if there is new volume.
if newVolume
// Get the difference between the current and previous price.
pdiff = price.get(0) - price.get(1)
// Evaluate the price direction, then update the price difference.
dir = pdiff == 0 ? 0 : math.sign(pdiff)
changeDir = (dir > 0 and prevDir < 0) or (dir < 0 and prevDir > 0)
prevDir := dir != 0 ? dir : prevDir
// Set the bullish, bearish, absorbed, and total volume metrics.
switch dir
1 => bull += vsize
0 => abso += vsize
-1 => bear += vsize
totl += vsize
// Set the bull-bear ratio, adding absorbed to the denominator.
rtio := bull > bear ? nz(bull / (bear + abso)) : bear > bull ? nz(-bear / (bull + abso)) : 0
// Set the moving and accumulating volumes, based on price action.
move := dir == 0 ? move : changeDir ? vsize * dir : move + vsize * dir
volAtPrice := dir == 0 ? volAtPrice + vsize : vsize
accu := dir != 0 ? 0 : volAtPrice
// Put the volume metric values into an array.
vmValues = array.from(bull, bear, abso, totl, rtio, move, accu)
// Show the volume metrics header.
metHedRow = invertTape ? tlen + 2 : 0
tape.cell(0, metHedRow, " VOLUME ", bgcolor=hdrc, text_color=hdrt, text_size=tsiz, text_halign=text.align_center), tape.merge_cells(0, metHedRow, headrArr - 1, metHedRow)
// For each volume metric the trader has enabled…
m = 0
for [i, showMetric] in vmVis
if showMetric
// Increment the row.
m += 1
row = invertTape ? tlen + 2 + m : m
// Get title and value of metric.
vmTitle = vmTitles.get(i)
vmValue = math.round(vmValues.get(i), vmPrsn)
// Check if a key signal level has been touched.
keyLvl = vmSig.get(i)
signal = vmValue >= keyLvl or vmValue <= -keyLvl
// Show enabled volume metric.
for col = 0 to 1
rowLabel = col == 0
tape.cell(col, row, rowLabel ? vmTitle : str.tostring(vmValue), 0, 0, signal ? lSzt : deft, rowLabel ? text.align_left : text.align_center, text.align_center, tsiz, signal ? lSzc : defc)
// Merge the metrics value cell with any remaining table columns in that row.
tape.merge_cells(1, row, headrArr - 1, row)
// Visually separate volume metrics from the time and sales.
tape.cell(0, invertTape ? tlen + 1 : m + 1, "", height=1, text_color=none, bgcolor=none)
// Set the metric offset, plus the header and visual separation.
metricOffset := m + 2
else
metricOffset := 0
// Show column headers of tape.
headerRow = invertTape ? tlen : metricOffset
for [col, colHeader] in hdrStr
tape.cell(col, headerRow, colHeader, bgcolor=hdrc, text_color=hdrt, text_size=tsiz, text_halign= col != 1 ? text.align_left : text.align_center)
// Set the direction the tape should scroll.
extraData = priceArr > tlen ? priceArr - tlen + 1 : 2
// Iterate through price, volume, and timestamp arrays until the trader defined number of rows is reached.
for i = 0 to priceArr - extraData
// Check if the price at index "i" is higher or lower than previous price in array.
p1 = price.get(i)
p2 = price.get(i + 1)
up = p1 > p2
dn = p1 < p2
// Get volume size at index "i" and check if it meets the traders large print criteria.
v = vol.get(i)
large = v >= lrg
space = large and big ? " \n " : " "
// Set which row to update.
row = invertTape ? tlen - 1 - i : metricOffset + 1 + i
// Set the rows price, volume, and time data.
rowStr = array.from(space + str.tostring(p1) + space, space + str.tostring(math.round(v, prsn)) + space, space + str.format_time(stamp.get(i), frmt, tmzn) + space)
// Print and color rows that have data.
for col = 0 to headrArr - 1
largeSize = col == 1 and large and hlt
bgClr = largeSize ? lSzc : up ? pUpc : dn ? pDnc : defc
txtClr = largeSize ? lSzt : up ? pUpt : dn ? pDnt : deft
tape.cell(col, row, rowStr.get(col), 0, 0, txtClr, col == 1 ? text.align_center : text.align_left, text.align_center, tsiz, bgClr)
// Print empty rows too.
if priceArr < tlen + 1
for i = 0 to tlen - nz(priceArr)
row = invertTape ? i : metricOffset + priceArr + i
for col = 0 to headrArr - 1
tape.cell(col, row, "", bgcolor=defc)
if priceArr > tlen + 1
// Remove oldest item in the arrays, if they exceed the trader specified row count.
price.pop(), vol.pop(), stamp.pop()
else if priceArr < 2
// Inform the trader there is no realtime data, if there are fewer than 2 prices to compare.
tape.cell(0, 0, "\n\t\t\t Waiting for real-time market data ... \t\t\t\n\n", bgcolor=defc, text_color=deft, text_size=tsiz)
newVolume := false |
Conceptive Price Moving Average [CSM] | https://www.tradingview.com/script/YUsTSSsF-Conceptive-Price-Moving-Average-CSM/ | chhagansinghmeena | https://www.tradingview.com/u/chhagansinghmeena/ | 40 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © chhagansinghmeena
//@version=5
indicator("Conceptive Price Moving Average [CSM]", shorttitle = "CPMA by CSM", overlay=true)
// Define the length of the moving average
source = input.source(title = "CMA Source", defval = close, group = "CSM CPMA")
length = input.int(21, "CMA Length", minval=1, group = "CSM CPMA")
length_09 = input.int(9, "EMA 9", minval=1, group = "EMA")
length_20 = input.int(20, "EMA 20", minval=20, group = "EMA")
length_50 = input.int(50, "EMA 50", minval=50, group = "EMA")
length_100 = input.int(100, "EMA 100", minval=100, group = "EMA")
length_200 = input.int(200, "EMA 200", minval=200, group = "EMA")
// Get various price types
[Open, price, High, Low , HL2, HLC3, HLCC4, OHLC4 ] = request.security(syminfo.tickerid, timeframe.period, [open, close, high, low, hl2, hlc3, hlcc4, ohlc4])
// Calculate the average of the last 3 candles for each price type
price_avg = ta.ema(price, length)
HL2_avg = ta.sma(HL2, length)
Open_avg = ta.ema(Open, length)
High_avg = ta.sma(High, length)
Low_avg = ta.ema(Low, length)
OHLC4_avg = ta.sma(OHLC4, length)
HLC3_avg = ta.ema(HLC3, length)
HLCC4_avg = ta.sma(HLCC4, length)
// Calculate the average of the price types
price_average = (price_avg + HL2_avg + Open_avg + High_avg + Low_avg + OHLC4_avg + HLC3_avg + HLCC4_avg) / 8
price_average := na(price_average[1]) ? price_average : price_average[1] + (source - price_average[1]) / (length * math.pow(source/price_average[1], 4))
ema9 = ta.ema(close,length_09)
ema20 = ta.ema(close,length_20)
ema50 = ta.ema(close,length_50)
ema100 = ta.ema(close,length_100)
ema200 = ta.ema(close,length_200)
// Plot the average on the chart
plot(price_average, color=color.blue, linewidth=2, title="CPMA")
plot(ema9, color=color.red, linewidth=1, title="EMA 9")
plot(ema20, color=color.green, linewidth=2, title="EMA 20")
plot(ema50, color=color.orange, linewidth=3, title="EMA 50")
plot(ema100, color=color.yellow, linewidth=4, title="EMA 100")
plot(ema200, color=color.white, linewidth=4, title="EMA 200")
|
Bullish Flag Patterns [theEccentricTrader] | https://www.tradingview.com/script/XL02MdYv-Bullish-Flag-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 47 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bullish Flag Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 350)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
returnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
uptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
downtrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
returnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
addUnbrokenPeak = input(defval = false, title = 'Unbroken Peaks', group = 'Logic')
unbrokenPeak = addUnbrokenPeak ? high < peak : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
beRangeRatio = (shPriceOne - trough) / (shPriceOne - slPriceTwo) * 100
abRatio = input(defval = 100, title = 'AB Minimum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
beRatio = input(defval = 40, title = 'BE Maximum Ratio', group = 'Range Ratios')
bullishFlag = slPrice and returnLineDowntrend and downtrend and uptrend[1] and unbrokenPeak
and shRangeRatioOne >= abRatio
and slRangeRatioOne <= bcRatio
and beRangeRatio <= beRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.green, title = 'Flag Color', group = 'Pattern Lines')
selectFlagExtend = input.string(title = 'Extend Current Flag Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendFlagLines = selectFlagExtend == 'None' ? extend.none : selectFlagExtend == 'Right' ? extend.right :
selectFlagExtend == 'Left' ? extend.left : selectFlagExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentResistanceLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentSupportLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bullishFlag
lineOne = line.new(slPriceBarIndexTwo, slPriceTwo, shPriceBarIndexOne, shPriceOne, color = poleColor, width = 2)
lineTwo = line.new(shPriceBarIndexOne, shPriceOne, peakBarIndex, peak, color = flagColor, width = 2)
lineThree = line.new(slPriceBarIndexOne, slPriceOne, slPriceBarIndex, slPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? slPriceBarIndex : na, showProjections ? slPrice : na, showProjections ? bar_index + 1 : na,
showProjections ? slPrice : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na, showProjections ? bar_index + 1 : na,
showProjections ? peak + (shPriceOne - slPriceTwo) : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? slPriceBarIndexTwo : na, showProjections ? slPriceTwo : na, showProjections ? bar_index + 1 : na,
showProjections ? slPriceTwo : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentResistanceLine, shPriceBarIndexOne, shPriceOne)
line.set_xy2(currentResistanceLine, peakBarIndex, peak)
line.set_xy1(currentSupportLine, slPriceBarIndexOne, slPriceOne)
line.set_xy2(currentSupportLine, slPriceBarIndex, slPrice)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1: na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? slPriceBarIndex : na, showProjections ? slPrice : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1: na, showProjections ? slPrice : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? peakBarIndex : na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1: na, showProjections ? peak + (shPriceOne - slPriceTwo) : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? slPriceBarIndexTwo : na, showProjections ? slPriceTwo : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1: na, showProjections ? slPriceTwo : na)
labelOne = label.new(showLabels ? slPriceBarIndexTwo : na, showLabels ? slPriceTwo : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'A', textcolor = labelColor)
labelTwo = label.new(showLabels ? shPriceBarIndexOne : na, showLabels ? shPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'B (' + str.tostring(math.round(shRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelThree = label.new(showLabels ? slPriceBarIndexOne : na, showLabels ? slPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'C (' + str.tostring(math.round(slRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelFour = label.new(showLabels ? peakBarIndex : na, showLabels ? peak : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'D (' + str.tostring(math.round(shRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelFive = label.new(showLabels ? slPriceBarIndex : na, showLabels ? slPrice : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'E (' + str.tostring(math.round(beRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
array.push(myLabelArray, labelFour)
array.push(myLabelArray, labelFive)
if array.size(myLabelArray) >= 350
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bullish Flag')
|
Radar Rider | https://www.tradingview.com/script/GB8fMpfQ-Radar-Rider/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 33 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Radar Rider", max_lines_count = 500)
import peacefulLizard50262/Spider_Plot/1 as s
normalize(close, len) =>
(close - ta.lowest(close, len))/(ta.highest(close, len) - ta.lowest(close, len))
bes(source, alpha)=>
var float smoothed = na
smoothed := na(smoothed) ? source : alpha * source + (1 - alpha) * nz(smoothed[1])
max(src)=>
var float max = na
max := math.max(nz(max[1]), src)
min(src)=>
var float min = na
min := math.min(nz(min[1]), src)
min_max(src)=>
(src - min(src))/(max(src) - min(src)) * 100
slope(source, length, n_len, pre_smoothing = 0.15, post_smoothing = 0.7)=>
src = bes(source, pre_smoothing)
avg = array.new<float>(length, na)
for i = 1 to length
array.push(avg, (src - src[i]))
slope = normalize(bes(array.avg(avg), post_smoothing), n_len)
percent(x, y) =>
((y - x)/x)*100
derivative(_close, len_mad) =>
switch len_mad
1 => (_close - _close[1]) / 1
2 => (_close - _close[2]) / 2
3 => (_close + _close[1] - _close[2] - _close[3]) / 4
4 => (_close + 2 * _close[1] - 2 * _close[3] - _close[4]) / 8
5 => (_close + 3 * _close[1] + 2 * _close[2] - 2 * _close[3] - 3 * _close[4] - _close[5]) / 16
6 => (_close + 4 * _close[1] + 5 * _close[2] - 5 * _close[4] - 4 * _close[5] - _close[6]) / 32
7 => (_close + 5 * _close[1] + 9 * _close[2] + 5 * _close[3] - 5 * _close[4] - 9 * _close[5] - 5 * _close[6] - _close[7]) / 64
8 => (_close + 6 * _close[1] + 14 * _close[2] + 14 * _close[3] - 14 * _close[5] - 14 * _close[6] - 6 * _close[7] - _close[8]) / 128
9 => (_close + 7 * _close[1] + 20 * _close[2] + 28 * _close[3] + 14 * _close[4] - 14 * _close[5] - 28 * _close[6] - 20 * _close[7] - 7 * _close[8] - _close[9]) / 256
10 => (_close + 8 * _close[1] + 27 * _close[2] + 48 * _close[3] + 42 * _close[4] - 42 * _close[6] - 48 * _close[7] - 27 * _close[8] - 8 * _close[9] - _close[10]) / 512
stdev(x, n)=>
out = math.sqrt(math.sum(math.pow(x - ta.ema(x, n), 2), n) * 0.5) * 0.5
out
filter(src, filter)=>
filter ? (src + (src[1] * 2) + (src[2] * 2) + src[3])/6 : src
z(src, len, filter, back)=>
normalize((filter(src, filter) - ta.ema(filter(src, filter), len))/stdev(filter(src, filter), len), back)
rsi(close, len) =>
rsi = ta.rsi(close, len)
f = -math.pow(math.abs(math.abs(rsi - 50) - 50), 1 + math.pow(len / 14, 0.618) - 1) / math.pow(50, math.pow(len / 14, 0.618) - 1) + 50
rsia = if rsi > 50
f + 50
else
-f + 50
rsia
ema_diff(length, close, filter, len_norm) =>
normalize(ta.ema(filter(close, filter), 3) - ta.ema(filter(close, filter), length), len_norm)
percent_rank_ema_diff(length, close, filter, len_norm) =>
s.data_normalize(ta.percentrank(ta.ema(filter(close, filter), 5) - ta.ema(filter(close, filter), length), len_norm), "Custom", 1, 1, 1, 0, 100)
ema_diff_longer(length, close, filter, len_norm) =>
normalize(ta.ema(filter(close, filter), 15) - ta.ema(filter(close, filter), 20 + length), len_norm)
rsi_filter(length, close, filter) =>
s.data_normalize(filter(rsi(filter(close, true), length), filter), "Custom", 1, 1, 1, 0, 100)
rsi_diff_normalized(length, close, filter, len_mad, len_norm) =>
normalize(derivative(rsi(filter(close, filter), length), len_mad), len_norm)
z_score(length, close, filter, len_norm) =>
z(close, length, filter, len_norm)
ema_normalized(length, close, filter, len_norm) =>
normalize((length == 1 ? filter(close, filter) : ta.ema(filter(close, filter), (length - 1))), len_norm)
wma_volume_normalized(length, volume, filter, len_norm) =>
normalize(filter(ta.wma(volume, (length - 1)), filter), len_norm)
ema_close_diff_normalized(length, close, filter, len_mad, len_norm) =>
normalize(filter(derivative(ta.ema(close, length), len_mad), filter), len_norm)
momentum_normalized(length, close, filter, len_norm) =>
normalize(ta.mom(filter(close, filter), length), len_norm)
sma_diff_ratio_normalized(length, close, filter, len_norm) =>
normalize((ta.sma(filter(close[(-1 + length)], filter), len_norm) - ta.sma(filter(close, filter), len_norm))/-(length - 1), len_norm)
wma_close_open_diff_normalized(length, close, open, filter, len_norm) =>
normalize(filter(ta.wma(close, length) - ta.wma(open, length), filter), len_norm)
rma_high_low_diff_normalized(length, high, low, filter, len_norm) =>
normalize(filter(ta.rma(high - low, length), filter), len_norm)
roc_normalized(length, close, filter, len_norm) =>
normalize(ta.roc(filter(close, filter), length), len_norm)
obv_diff_normalized(length, obv, filter, len_norm) =>
normalize(filter(obv, filter) - ta.wma(filter(obv, filter), 2 + length), len_norm)
mfi_normalized(length, hlc3, filter, len_norm) =>
normalize(filter(ta.mfi(hlc3, length), filter), len_norm)
bb_ratio_normalized(length, close, filter, len_norm) =>
normalize(((ta.sma(filter(close, filter), length) + ta.stdev(filter(close, filter), length)) - (ta.sma(filter(close, filter), length) - ta.stdev(filter(close, filter), length)))/ta.sma(filter(close, filter), length), len_norm)
bb_ratio_percent_rank(length, close, filter, len_norm) =>
s.data_normalize(ta.percentrank(((ta.sma(filter(close, filter), length) + ta.stdev(filter(close, filter), length)) - (ta.sma(filter(close, filter), length) - ta.stdev(filter(close, filter), length)))/ta.sma(filter(close, filter), length), len_norm), "Custom", 1, 1, 1, 0, 100)
percent_diff_normalized(length, close, open, filter, len_norm) =>
normalize(percent(open[length], filter(close, filter)), len_norm)
slope_normalized(close, length, len_norm, filter) =>
slope(close, length, len_norm, 0.7)
stoch_sma(length, close, high, low, filter, stochSmaNormalizatoinLength) =>
normalize(ta.sma(ta.stoch(filter(close, filter), filter(high, filter), filter(low, filter), length), 3), stochSmaNormalizatoinLength)
emaDiffLength = input.int(14, "EMA Diff Length", 1)
emaDiffFilterStrength = input.int(2, "EMA Diff Filter Strength")
emaDiffLenNorm = input.int(25, "EMA Diff Length Normalization")
percentRankLength = input.int(14, "Percent Rank Length", 1)
percentRankEmaDiffFilterStrength = input.int(1, "Percent Rank EMA Diff Filter Strength")
percentRankEmaDiffLenNorm = input.int(25, "Percent Rank EMA Diff Length Normalization")
emaDiffLongerLength = input.int(14, "EMA Diff Longer Length", 1)
emaDiffLongerFilterStrength = input.int(2, "EMA Diff Longer Filter Strength")
emaDiffLongerLenNorm = input.int(25, "EMA Diff Longer Length Normalization")
rsiFilterLength = input.int(14, "RSI Filter Length", 1)
rsiFilterFilterStrength = input.int(1, "RSI Filter Filter Strength")
rsiDiffNormalizedLength = input.int(14, "RSI Diff Normalized Length", 1)
rsiDiffNormalizedFilterStrength = input.int(2, "RSI Diff Normalized Filter Strength")
rsiDiffNormalizedLenNorm = input.int(25, "RSI Diff Normalized Length Normalization")
rsiDiffNormalizedLenMed = input.int(4, "RSI Diff Normalized Diff Length", 1, 10)
zScoreLength = input.int(14, "Z Score Length", 1)
zScoreFilterStrength = input.int(2, "Z Score Filter Strength")
zScoreLenNorm = input.int(25, "Z Score Length Normalization")
emaNormalizedLength = input.int(14, "EMA Normalized Length", 1)
emaNormalizedFilterStrength = input.int(2, "EMA Normalized Filter Strength")
emaNormalizedLenNorm = input.int(25, "EMA Normalized Length Normalization")
wmaVolumeNormalizedLength = input.int(14, "WMA Volume Normalized Length", 1)
wmaVolumeNormalizedFilterStrength = input.int(2, "WMA Volume Normalized Filter Strength")
wmaVolumeNormalizedLenNorm = input.int(25, "WMA Volume Normalized Length Normalization")
emaCloseDiffNormalizedLength = input.int(14, "EMA Close Diff Normalized Length", 1)
emaCloseDiffNormalizedFilterStrength = input.int(2, "EMA Close Diff Normalized Filter Strength")
emaCloseDiffNormalizedLenNorm = input.int(25, "EMA Close Diff Normalized Length Normalization")
emaCloseDiffNormalizedLenMed = input.int(4, "Ema Close Diff Normalized Diff Length", 1, 10)
momentumNormalizedLength = input.int(14, "Momentum Normalized Length", 1)
momentumNormalizedFilterStrength = input.int(2, "Momentum Normalized Filter Strength")
momentumNormalizedLenNorm = input.int(25, "Momentum Normalized Length Normalization")
smaDiffRatioNormalizedLength = input.int(14, "SMA Diff Ratio Normalized Length", 1)
smaDiffRatioNormalizedFilterStrength = input.int(2, "SMA Diff Ratio Normalized Filter Strength")
smaDiffRatioNormalizedLenNorm = input.int(25, "SMA Diff Ratio Normalized Length Normalization")
wmaCloseOpenDiffNormalizedLength = input.int(14, "WMA Close Open Diff Normalized Length", 1)
wmaCloseOpenDiffNormalizedFilterStrength = input.int(2, "WMA Close Open Diff Normalized Filter Strength")
wmaCloseOpenDiffNormalizedLenNorm = input.int(25, "WMA Close Open Diff Normalized Length Normalization")
rmaHighLowDiffNormalizedLength = input.int(14, "RMA High Low Diff Normalized Length", 1)
rmaHighLowDiffNormalizedFilterStrength = input.int(2, "RMA High Low Diff Normalized Filter Strength")
rmaHighLowDiffNormalizedLenNorm = input.int(25, "RMA High Low Diff Normalized Length Normalization")
rocNormalizedLength = input.int(14, "ROC Normalized Length", 1)
rocNormalizedFilterStrength = input.int(2, "ROC Normalized Filter Strength")
rocNormalizedLenNorm = input.int(25, "ROC Normalized Length Normalization")
obvDiffNormalizedLength = input.int(14, "OBV Diff Normalized Length", 1)
obvDiffNormalizedFilterStrength = input.int(2, "OBV Diff Normalized Filter Strength")
obvDiffNormalizedLenNorm = input.int(25, "OBV Diff Normalized Length Normalization")
mfiNormalizedLength = input.int(14, "MFI Normalized Length", 1)
mfiNormalizedFilterStrength = input.int(2, "MFI Normalized Filter Strength")
mfiNormalizedLenNorm = input.int(25, "MFI Normalized Length Normalization")
bbRatioNormalizedLength = input.int(14, "BB Ratio Normalized Length", 1)
bbRatioNormalizedFilterStrength = input.int(2, "BB Ratio Normalized Filter Strength")
bbRatioNormalizedLenNorm = input.int(25, "BB Ratio Normalized Length Normalization")
bbRatioPercentRankLength = input.int(14, "BB Ratio Percent Rank Length", 1)
bbRatioPercentRankFilterStrength = input.int(2, "BB Ratio Percent Rank Filter Strength")
bbRatioPercentRankLenNorm = input.int(25, "BB Ratio Percent Rank Length Normalization")
percentDiffNormalizedLength = input.int(14, "Percent Diff Normalized Length", 1)
percentDiffNormalizedFilterStrength = input.int(2, "Percent Diff Normalized Filter Strength")
percentDiffNormalizedLenNorm = input.int(25, "Percent Diff Normalized Length Normalization")
slopeNormalizedLength = input.int(14, "Slope Normalized Length", 1)
slopeNormalizedFilterStrength = input.int(2, "Slope Normalized Filter Strength")
slopeNormalizedLenNorm = input.int(25, "Slope Normalized Length Normalization")
stochSmaLength = input.int(14, "Stoch SMA Length", 1)
stochSmaFilterStrength = input.int(2, "Stoch SMA Filter Strength")
stochSmaNormalizatoinLength = input.int(25, "Stoch SMA Normalizatoin Length")
axes_color = input.color(color.gray, "Axes Color")
scale = input.int(30, "Scale")
color_emaDiff = input.color(#FF6666, "EMA Diff Color")
color_percentRankEmaDiff = input.color(#66FF66, "Percent Rank EMA Diff Color")
color_emaDiffLonger = input.color(#FFA500, "EMA Diff Longer Color")
color_rsiFilter = input.color(#00FFFF, "RSI Filter Color")
color_rsiDiffNormalized = input.color(#9B30FF, "RSI Diff Normalized Color")
color_zScore = input.color(#4444ff, "Z Score Color")
color_emaNormalized = input.color(#32CD32, "EMA Normalized Color")
color_wmaVolumeNormalized = input.color(#FF4500, "WMA Volume Normalized Color")
color_emaCloseDiffNormalized = input.color(#4169E1, "EMA Close Diff Normalized Color")
color_momentumNormalized = input.color(#8B008B, "Momentum Normalized Color")
color_smaDiffRatioNormalized = input.color(#EE82EE, "SMA Diff Ratio Normalized Color")
color_wmaCloseOpenDiffNormalized = input.color(#2E8B57, "WMA Close Open Diff Normalized Color")
color_rmaHighLowDiffNormalized = input.color(#FFD700, "RMA High Low Diff Normalized Color")
color_rocNormalized = input.color(#BA55D3, "ROC Normalized Color")
color_obvDiffNormalized = input.color(#FF6347, "OBV Diff Normalized Color")
color_mfiNormalized = input.color(#3CB371, "MFI Normalized Color")
color_bbRatioNormalized = input.color(#B22222, "BB Ratio Normalized Color")
color_bbRatioPercentRank = input.color(#008080, "BB Ratio Percent Rank Color")
color_percentDiffNormalized = input.color(#6A5ACD, "Percent Diff Normalized Color")
color_slopeNormalized = input.color(#556B2F, "Slope Normalized Color")
color_stochSma = input.color(#800080, "Stoch SMA Color")
emaDiffVar = ema_diff(emaDiffLength, close, emaDiffFilterStrength, emaDiffLenNorm)
percentRankEmaDiffVar = percent_rank_ema_diff(percentRankLength, close, percentRankEmaDiffFilterStrength, percentRankEmaDiffLenNorm)
emaDiffLongerVar = ema_diff_longer(emaDiffLongerLength, close, emaDiffLongerFilterStrength, emaDiffLongerLenNorm)
rsiFilterVar = rsi_filter(rsiFilterLength, close, rsiFilterFilterStrength)
rsiDiffNormalizedVar = rsi_diff_normalized(rsiDiffNormalizedLength, close, rsiDiffNormalizedFilterStrength, rsiDiffNormalizedLenMed,rsiDiffNormalizedLenNorm) ///
zScoreVar = z_score(zScoreLength, close, zScoreFilterStrength, zScoreLenNorm)
emaNormalizedVar = ema_normalized(emaNormalizedLength, close, emaNormalizedFilterStrength, emaNormalizedLenNorm)
wmaVolumeNormalizedVar = wma_volume_normalized(wmaVolumeNormalizedLength, volume, wmaVolumeNormalizedFilterStrength, wmaVolumeNormalizedLenNorm)
emaCloseDiffNormalizedVar = ema_close_diff_normalized(emaCloseDiffNormalizedLength, close, emaCloseDiffNormalizedFilterStrength, emaCloseDiffNormalizedLenMed,emaCloseDiffNormalizedLenNorm) ///
momentumNormalizedVar = momentum_normalized(momentumNormalizedLength, close, momentumNormalizedFilterStrength, momentumNormalizedLenNorm)
smaDiffRatioNormalizedVar = sma_diff_ratio_normalized(smaDiffRatioNormalizedLength, close, smaDiffRatioNormalizedFilterStrength, smaDiffRatioNormalizedLenNorm)
wmaCloseOpenDiffNormalizedVar = wma_close_open_diff_normalized(wmaCloseOpenDiffNormalizedLength, close, open, wmaCloseOpenDiffNormalizedFilterStrength, wmaCloseOpenDiffNormalizedLenNorm)
rmaHighLowDiffNormalizedVar = rma_high_low_diff_normalized(rmaHighLowDiffNormalizedLength, high, low, rmaHighLowDiffNormalizedFilterStrength, rmaHighLowDiffNormalizedLenNorm)
rocNormalizedVar = roc_normalized(rocNormalizedLength, close, rocNormalizedFilterStrength, rocNormalizedLenNorm)
obvDiffNormalizedVar = obv_diff_normalized(obvDiffNormalizedLength, ta.obv, obvDiffNormalizedFilterStrength, obvDiffNormalizedLenNorm)
mfiNormalizedVar = mfi_normalized(mfiNormalizedLength, hlc3, mfiNormalizedFilterStrength, mfiNormalizedLenNorm)
bbRatioNormalizedVar = bb_ratio_normalized(bbRatioNormalizedLength, close, bbRatioNormalizedFilterStrength, bbRatioNormalizedLenNorm)
bbRatioPercentRankVar = bb_ratio_percent_rank(bbRatioPercentRankLength, close, bbRatioPercentRankFilterStrength, bbRatioPercentRankLenNorm)
percentDiffNormalizedVar = percent_diff_normalized(percentDiffNormalizedLength, close, open, percentDiffNormalizedFilterStrength, percentDiffNormalizedLenNorm)
slopeNormalizedVar = slope_normalized(close, slopeNormalizedLength, slopeNormalizedLenNorm, slopeNormalizedFilterStrength)
stochSmaVar = stoch_sma(stochSmaLength, close, high, low, stochSmaFilterStrength, stochSmaNormalizatoinLength)
data = array.from(
emaDiffVar
, percentRankEmaDiffVar
, emaDiffLongerVar
, rsiFilterVar
, rsiDiffNormalizedVar
, zScoreVar
, emaNormalizedVar
, wmaVolumeNormalizedVar
, emaCloseDiffNormalizedVar
, momentumNormalizedVar
, smaDiffRatioNormalizedVar
, wmaCloseOpenDiffNormalizedVar
, rmaHighLowDiffNormalizedVar
, rocNormalizedVar
, obvDiffNormalizedVar
, mfiNormalizedVar
, bbRatioNormalizedVar
, bbRatioPercentRankVar
, percentDiffNormalizedVar
, slopeNormalizedVar
, stochSmaVar
)
data_color = array.from(
color_emaDiff,
color_percentRankEmaDiff,
color_emaDiffLonger,
color_rsiFilter,
color_rsiDiffNormalized,
color_zScore,
color_emaNormalized,
color_wmaVolumeNormalized,
color_emaCloseDiffNormalized,
color_momentumNormalized,
color_smaDiffRatioNormalized,
color_wmaCloseOpenDiffNormalized,
color_rmaHighLowDiffNormalized,
color_rocNormalized,
color_obvDiffNormalized,
color_mfiNormalized,
color_bbRatioNormalized,
color_bbRatioPercentRank,
color_percentDiffNormalized,
color_slopeNormalized,
color_stochSma
)
s.draw_spider_plot(data, data_color, axes_color, scale)
|
Trend Reversal Probability Calculator | https://www.tradingview.com/script/dwzOuO3c-Trend-Reversal-Probability-Calculator/ | cyatophilum | https://www.tradingview.com/u/cyatophilum/ | 734 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © cyatophilum
//@version=5
indicator("Trend Reversal Probability Calculator",overlay=true)
// Inputs {
theme = input.string('Light','Color Theme',options=['Dark','Light'])
groupEMA = 'Moving Averages'
length1 = input.int(10, 'MA 1', group = groupEMA)
length2 = input.int(20, 'MA 2', group = groupEMA)
length3 = input.int(30,'MA 3', group = groupEMA)
length4 = input.int(40,'MA 4', group = groupEMA)
length5 = input.int(50,'MA 5', group = groupEMA)
length6 = input.int(60,'MA 6', group = groupEMA)
length7 = input.int(70,'MA 7', group = groupEMA)
length8 = input.int(80,'MA 8', group = groupEMA)
length9 = input.int(90,'MA 9', group = groupEMA)
length10 = input.int(100,'MA 10', group = groupEMA)
length11 = input.int(200,'MA 11 (long term)', group = groupEMA)
groupTrend = 'Trend'
rocLength = input.int(14,'ROC length (Trend sensitivity)', group = groupTrend)
signalPercentage = input.int(5,'Reversal sensitivity (1 to 9)',minval = 1,maxval = 9, group = groupTrend)
//}
ma1 = ta.sma(close,length1)
ma2 = ta.sma(close,length2)
ma3 = ta.sma(close,length3)
ma4 = ta.sma(close,length4)
ma5 = ta.sma(close,length5)
ma6 = ta.sma(close,length6)
ma7 = ta.sma(close,length7)
ma8 = ta.sma(close,length8)
ma9 = ta.sma(close,length9)
ma10 = ta.sma(close,length10)
ma11 = ta.sma(close,length11)
roc1 = ta.roc(ma1,rocLength)
roc2 = ta.roc(ma2,rocLength)
roc3 = ta.roc(ma3,rocLength)
roc4 = ta.roc(ma4,rocLength)
roc5 = ta.roc(ma5,rocLength)
roc6 = ta.roc(ma6,rocLength)
roc7 = ta.roc(ma7,rocLength)
roc8 = ta.roc(ma8,rocLength)
roc9 = ta.roc(ma9,rocLength)
roc10 = ta.roc(ma10,rocLength)
roc11 = ta.roc(ma11,rocLength)
// If the short-term moving average starts to slope in the opposite direction of the long-term moving average (e.g., 200-day), it may indicate a potential trend reversal.
trendReversalBull1 = roc1 > 0 and roc11 < 0
trendReversalBull2 = roc2 > 0 and roc11 < 0
trendReversalBull3 = roc3 > 0 and roc11 < 0
trendReversalBull4 = roc4 > 0 and roc11 < 0
trendReversalBull5 = roc5 > 0 and roc11 < 0
trendReversalBull6 = roc6 > 0 and roc11 < 0
trendReversalBull7 = roc7 > 0 and roc11 < 0
trendReversalBull8 = roc8 > 0 and roc11 < 0
trendReversalBull9 = roc9 > 0 and roc11 < 0
trendReversalBull10 = roc10 > 0 and roc11 < 0
countBull =
(trendReversalBull1 ? 1 : 0) +
(trendReversalBull2 ? 1 : 0) +
(trendReversalBull3 ? 1 : 0) +
(trendReversalBull4 ? 1 : 0) +
(trendReversalBull5 ? 1 : 0) +
(trendReversalBull7 ? 1 : 0) +
(trendReversalBull8 ? 1 : 0) +
(trendReversalBull9 ? 1 : 0) +
(trendReversalBull10 ? 1 : 0)
trendReversalBear1 = roc1 < 0 and roc11 > 0
trendReversalBear2 = roc2 < 0 and roc11 > 0
trendReversalBear3 = roc3 < 0 and roc11 > 0
trendReversalBear4 = roc4 < 0 and roc11 > 0
trendReversalBear5 = roc5 < 0 and roc11 > 0
trendReversalBear6 = roc6 < 0 and roc11 > 0
trendReversalBear7 = roc7 < 0 and roc11 > 0
trendReversalBear8 = roc8 < 0 and roc11 > 0
trendReversalBear9 = roc9 < 0 and roc11 > 0
trendReversalBear10 = roc10 < 0 and roc11 > 0
countBear =
(trendReversalBear1 ? 1 : 0) +
(trendReversalBear2 ? 1 : 0) +
(trendReversalBear3 ? 1 : 0) +
(trendReversalBear4 ? 1 : 0) +
(trendReversalBear5 ? 1 : 0) +
(trendReversalBear7 ? 1 : 0) +
(trendReversalBear8 ? 1 : 0) +
(trendReversalBear9 ? 1 : 0) +
(trendReversalBear10 ? 1 : 0)
bull = ta.crossover(roc11,0)
bear = ta.crossunder(roc11,0)
reversalBull = ta.crossover(countBull,signalPercentage) and not bear
reversalBear = ta.crossover(countBear,signalPercentage) and not bull
// Render {
color colorRibbon = na
color colorRibbonA = na
color frameColor = na
if theme == 'Light'
colorRibbon := roc11 > 0 ? color.rgb(255, 255 - 255/10*countBear, 255 - 255/10*countBear) : color.rgb(255 - 255/10*countBull, 255, 255 - 255/10*countBull)
colorRibbonA := roc11 > 0 ? color.rgb(255 ,255 - 255/10*countBear, 255 - 255/10*countBear, 70) : color.rgb(255 - 255/10*countBull ,255, 255 - 255/10*countBull, 70)
frameColor := roc11 > 0 ? color.rgb(0,255,0) : color.rgb(255,0,0)
else
colorRibbon := roc11 > 0 ? color.rgb(255/10*countBear, 0, 0) : color.rgb(0, 255/10*countBull, 0)
colorRibbonA := roc11 > 0 ? color.rgb(255/10*countBear, 0, 0, 70) : color.rgb(0, 255/10*countBull, 0, 70)
frameColor := roc11 > 0 ? color.rgb(0, 255, 0, 50) : color.rgb(255,0,0,50)
if barstate.islast
info = table.new(position.top_right,2,2,bgcolor = colorRibbonA,frame_color = frameColor, frame_width = 2)
table.cell(info,0,0,'Current Trend:',text_color = chart.fg_color)
table.cell(info,1,0,roc11 > 0 ? 'Bull' : 'Bear',text_color = roc11 > 0 ? color.green : color.rgb(224, 0, 0), text_font_family = font.family_monospace,text_size = size.large)
table.cell(info,0,1,roc11 > 0 ? 'Reversal Bear Probability:' : 'Reversal Bull Probability:',text_color = chart.fg_color)
table.cell(info,1,1,roc11 > 0 ? str.tostring(countBear*10) + '%' : str.tostring(countBull*10) + '%',text_color = chart.fg_color)
plot(roc1,'roc1',display = display.data_window)
plot(roc2,'roc2',display = display.data_window)
plot(roc3,'roc3',display = display.data_window)
p1 = plot(ma1,'MA 1', colorRibbon)
p2 = plot(ma2,'MA 2', colorRibbon)
p3 = plot(ma3,'MA 3', colorRibbon)
p4 = plot(ma4,'MA 4', colorRibbon)
p5 = plot(ma5,'MA 5', colorRibbon)
p6 = plot(ma6,'MA 6', colorRibbon)
p7 = plot(ma7,'MA 7', colorRibbon)
p8 = plot(ma8,'MA 8', colorRibbon)
p9 = plot(ma9,'MA 9', colorRibbon)
p10 = plot(ma10,'MA 10',colorRibbon)
p11 = plot(ma11,'MA 11',linewidth = 3, color = frameColor)
fill(p1,p2,color=colorRibbonA)
fill(p2,p3,color=colorRibbonA)
fill(p3,p4,color=colorRibbonA)
fill(p4,p5,color=colorRibbonA)
fill(p5,p6,color=colorRibbonA)
fill(p6,p7,color=colorRibbonA)
fill(p7,p8,color=colorRibbonA)
fill(p8,p9,color=colorRibbonA)
fill(p9,p10,color=colorRibbonA)
plotcandle(open,high,low,close,'candles',roc11 > 0 ? color.rgb(0,255,0) : color.rgb(255,0,0))
labelColorBull = theme == 'Light' ? color.lime : color.rgb(0, 230, 119, 50)
labelColorBear = theme == 'Light' ? color.red : color.rgb(230, 0, 0, 50)
labelTextColor = theme == 'Light' ? color.black : color.white
plotshape(bull, 'Bull',shape.labelup, location.belowbar,labelColorBull,0,'Bull',labelTextColor,size=size.small)
plotshape(bear, 'Bear',shape.labeldown,location.abovebar,labelColorBear,0, 'Bear',labelTextColor,size=size.small)
plotshape(reversalBear, 'Reversal Bear',shape.labeldown,location.abovebar,labelColorBear,0, 'ReversalBear',labelTextColor,size=size.small)
plotshape(reversalBull, 'Reversal Bull',shape.labelup, location.belowbar,labelColorBull,0,'Reversal Bull',labelTextColor,size=size.small)
// }
// Alerts {
alertcondition(bull, 'Bull Signal')
alertcondition(bear, 'Bear Signal')
alertcondition(reversalBull, 'Reversal Bull')
alertcondition(reversalBear, 'Reversal Bear')
//} |
Forex Radar | https://www.tradingview.com/script/apQu9bpB-Forex-Radar/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 41 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Forex Radar", "FR", false, max_lines_count = 500, max_labels_count = 500)
import peacefulLizard50262/Spider_Plot/1 as s
normalize(close, len) =>
(close - ta.lowest(close, len))/(ta.highest(close, len) - ta.lowest(close, len))
ema_diff_state(state, a, b) =>
state ? a : b
state = input.bool(false, "Switch to the other set.")
style = input.bool(true, "Select Style", "True is rsi, false is ema divergance.")
axes_color = input.color(color.gray, "Axes Color")
scale = input.int(30, "Scale", 1)
length = input.int(200, "EMA Divergance Length", 5)
length_rsi = input.int(14, "RSI Length", 3)
filter = input.int(2, "Smooting", 1)
len_norm = input.int(200, "Normalization Lookback", 5)
color_AUD = input.color(color.new(#FF9900, 70), "AUD Color") // Australia - Orange
color_CAD = input.color(color.new(#FF0000, 70), "CAD Color") // Canada - Red
color_CHF = input.color(color.new(#FFD700, 70), "CHF Color") // Switzerland - Gold
color_EUR = input.color(color.new(#0000FF, 70), "EUR Color") // European Union - Blue
color_GBP = input.color(color.new(#228B22, 70), "GBP Color") // United Kingdom - Green
color_JPY = input.color(color.new(#B22222, 70), "JPY Color") // Japan - Maroon
color_NZD = input.color(color.new(#663388, 70), "NZD Color") // New Zealand - Purple
color_USD = input.color(color.new(#1E90FF, 70), "USD Color") // United States - Light Blue
ema_diff() =>
not style ? normalize(ta.ema(close, 3) - ta.ema(close, length), len_norm) : ta.rsi(ta.sma(close, filter), length_rsi) / 100
// AUD pairs
selected_ema_diff_AUD1 = ema_diff_state(state, request.security("OANDA:AUDCAD", timeframe.period, ema_diff()), request.security("OANDA:AUDCHF", timeframe.period, ema_diff()))
selected_ema_diff_AUD2 = ema_diff_state(state, request.security("OANDA:AUDJPY", timeframe.period, ema_diff()), request.security("OANDA:AUDNZD", timeframe.period, ema_diff()))
selected_ema_diff_AUD3 = ema_diff_state(state, request.security("OANDA:AUDUSD", timeframe.period, ema_diff()), request.security("OANDA:EURAUD", timeframe.period, ema_diff()))
selected_ema_diff_AUD4 = ema_diff_state(state, request.security("OANDA:GBPAUD", timeframe.period, ema_diff()), request.security("OANDA:GBPAUD", timeframe.period, ema_diff()))
// CAD pairs
selected_ema_diff_CAD1 = ema_diff_state(state, request.security("OANDA:AUDCAD", timeframe.period, ema_diff()), request.security("OANDA:CADCHF", timeframe.period, ema_diff()))
selected_ema_diff_CAD2 = ema_diff_state(state, request.security("OANDA:CADJPY", timeframe.period, ema_diff()), request.security("OANDA:EURCAD", timeframe.period, ema_diff()))
selected_ema_diff_CAD3 = ema_diff_state(state, request.security("OANDA:GBPCAD", timeframe.period, ema_diff()), request.security("OANDA:NZDCAD", timeframe.period, ema_diff()))
// CHF pairs
selected_ema_diff_CHF1 = ema_diff_state(state, request.security("OANDA:CHFJPY", timeframe.period, ema_diff()), request.security("OANDA:EURCHF", timeframe.period, ema_diff()))
selected_ema_diff_CHF2 = ema_diff_state(state, request.security("OANDA:GBPCHF", timeframe.period, ema_diff()), request.security("OANDA:NZDCHF", timeframe.period, ema_diff()))
// EUR pairs
selected_ema_diff_EUR1 = ema_diff_state(state, request.security("OANDA:EURCAD", timeframe.period, ema_diff()), request.security("OANDA:EURCHF", timeframe.period, ema_diff()))
selected_ema_diff_EUR2 = ema_diff_state(state, request.security("OANDA:EURGBP", timeframe.period, ema_diff()), request.security("OANDA:EURJPY", timeframe.period, ema_diff()))
selected_ema_diff_EUR3 = ema_diff_state(state, request.security("OANDA:EURNZD", timeframe.period, ema_diff()), request.security("OANDA:EURUSD", timeframe.period, ema_diff()))
// GBP pairs
selected_ema_diff_GBP1 = ema_diff_state(state, request.security("OANDA:GBPCAD", timeframe.period, ema_diff()), request.security("OANDA:GBPCHF", timeframe.period, ema_diff()))
selected_ema_diff_GBP2 = ema_diff_state(state, request.security("OANDA:GBPJPY", timeframe.period, ema_diff()), request.security("OANDA:GBPNZD", timeframe.period, ema_diff()))
selected_ema_diff_GBP3 = ema_diff_state(state, request.security("OANDA:GBPUSD", timeframe.period, ema_diff()), request.security("OANDA:GBPUSD", timeframe.period, ema_diff()))
// JPY pairs
selected_ema_diff_JPY1 = ema_diff_state(state, request.security("OANDA:CADJPY", timeframe.period, ema_diff()), request.security("OANDA:CHFJPY", timeframe.period, ema_diff()))
selected_ema_diff_JPY2 = ema_diff_state(state, request.security("OANDA:EURJPY", timeframe.period, ema_diff()), request.security("OANDA:GBPJPY", timeframe.period, ema_diff()))
selected_ema_diff_JPY3 = ema_diff_state(state, request.security("OANDA:NZDJPY", timeframe.period, ema_diff()), request.security("OANDA:USDJPY", timeframe.period, ema_diff()))
// NZD pairs
selected_ema_diff_NZD1 = ema_diff_state(state, request.security("OANDA:NZDCAD", timeframe.period, ema_diff()), request.security("OANDA:NZDCHF", timeframe.period, ema_diff()))
selected_ema_diff_NZD2 = ema_diff_state(state, request.security("OANDA:NZDJPY", timeframe.period, ema_diff()), request.security("OANDA:NZDUSD", timeframe.period, ema_diff()))
// USD pairs
selected_ema_diff_USD1 = ema_diff_state(state, request.security("OANDA:USDCAD", timeframe.period, ema_diff()), request.security("OANDA:USDCHF", timeframe.period, ema_diff()))
selected_ema_diff_USD2 = ema_diff_state(state, request.security("OANDA:USDJPY", timeframe.period, ema_diff()), request.security("OANDA:USDCAD", timeframe.period, ema_diff()))
data = array.from(
selected_ema_diff_AUD1, selected_ema_diff_AUD2, selected_ema_diff_AUD3, selected_ema_diff_AUD4,
selected_ema_diff_CAD1, selected_ema_diff_CAD2, selected_ema_diff_CAD3,
selected_ema_diff_CHF1, selected_ema_diff_CHF2,
selected_ema_diff_EUR1, selected_ema_diff_EUR2, selected_ema_diff_EUR3,
selected_ema_diff_GBP1, selected_ema_diff_GBP2, selected_ema_diff_GBP3,
selected_ema_diff_JPY1, selected_ema_diff_JPY2, selected_ema_diff_JPY3,
selected_ema_diff_NZD1, selected_ema_diff_NZD2,
selected_ema_diff_USD1, selected_ema_diff_USD2
)
color_data = array.from(
color_AUD, color_AUD, color_AUD, color_AUD,
color_CAD, color_CAD, color_CAD,
color_CHF, color_CHF,
color_EUR, color_EUR, color_EUR,
color_GBP, color_GBP, color_GBP,
color_JPY, color_JPY, color_JPY,
color_NZD, color_NZD,
color_USD, color_USD
)
label_color = array.from(color_AUD, color_CAD, color_CHF, color_EUR, color_GBP, color_JPY, color_NZD, color_USD)
// Define labels for both sets
labels_AUD_set1 = array.from("AUDCAD", "AUDJPY", "AUDUSD", "GBPAUD")
labels_AUD_set2 = array.from("AUDCHF", "AUDNZD", "EURAUD", "GBPAUD")
labels_CAD_set1 = array.from("AUDCAD", "CADJPY", "GBPCAD")
labels_CAD_set2 = array.from("CADCHF", "EURCAD", "NZDCAD")
labels_CHF_set1 = array.from("CHFJPY", "GBPCHF")
labels_CHF_set2 = array.from("EURCHF", "NZDCHF")
labels_EUR_set1 = array.from("EURCAD", "EURGBP", "EURNZD")
labels_EUR_set2 = array.from("EURCHF", "EURJPY", "EURUSD")
labels_GBP_set1 = array.from("GBPCAD", "GBPJPY", "GBPUSD")
labels_GBP_set2 = array.from("GBPCHF", "GBPNZD", "GBPUSD")
labels_JPY_set1 = array.from("CADJPY", "EURJPY", "NZDJPY")
labels_JPY_set2 = array.from("CHFJPY", "GBPJPY", "USDJPY")
labels_NZD_set1 = array.from("NZDCAD", "NZDJPY")
labels_NZD_set2 = array.from("NZDCHF", "NZDUSD")
labels_USD_set1 = array.from("USDCAD", "USDJPY")
labels_USD_set2 = array.from("USDCHF", "USDCAD")
// Labels
var label_array = array.new_label(0)
// Function to draw labels
draw_labels(_labels_set, _label_colors, _offset, colour) =>
centerX = bar_index - 75 + _offset
y = -0.9
for i = 0 to array.size(_labels_set) - 1
array.push(label_array, label.new(centerX, y, text=array.get(_labels_set, i), color=array.get(_label_colors, colour), style=label.style_label_center, textcolor=color.white))
y := y + 0.5
if y >= -0.9 + 0.5 * 7
y := -0.9
centerX := centerX
if barstate.isconfirmed
for i = 0 to array.size(label_array) - 1
label.delete(array.get(label_array, i))
if barstate.islast
array.clear(label_array)
if state
draw_labels(labels_AUD_set1, label_color, 0, 0)
draw_labels(labels_CAD_set1, label_color, 6, 1)
draw_labels(labels_CHF_set1, label_color, 12, 2)
draw_labels(labels_EUR_set1, label_color, 18, 3)
draw_labels(labels_GBP_set1, label_color, 24, 4)
draw_labels(labels_JPY_set1, label_color, 30, 5)
draw_labels(labels_NZD_set1, label_color, 36, 6)
draw_labels(labels_USD_set1, label_color, 42, 7)
else
draw_labels(labels_AUD_set2, label_color, 0, 0)
draw_labels(labels_CAD_set2, label_color, 6, 1)
draw_labels(labels_CHF_set2, label_color, 12, 2)
draw_labels(labels_EUR_set2, label_color, 18, 3)
draw_labels(labels_GBP_set2, label_color, 24, 4)
draw_labels(labels_JPY_set2, label_color, 30, 5)
draw_labels(labels_NZD_set2, label_color, 36, 6)
draw_labels(labels_USD_set2, label_color, 42, 7)
else
for lbl in label_array
label.delete(lbl)
array.clear(label_array)
s.draw_spider_plot(data, color_data, axes_color, scale)
|
Goertzel Cycle Composite Wave [Loxx] | https://www.tradingview.com/script/wZwWxSpI-Goertzel-Cycle-Composite-Wave-Loxx/ | loxx | https://www.tradingview.com/u/loxx/ | 157 | study | 5 | MPL-2.0 | // 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("Goertzel Cycle Composite Wave [Loxx]", overlay = false, max_lines_count = 500)
color greencolor = #2DD204
color redcolor = #D2042D
string hpsmth = "Hodrick-Prescott Filter Smoothing"
string zlagsmth = "Zero-lag Moving Average Smoothing"
string hpsmthdt = "Hodrick-Prescott Filter Detrending"
string zlagsmthdt = "Zero-lag Moving Average Detrending"
string logZlagRegression = "Logarithmic Zero-lag Moving Average Regression Detrending"
string none = "None"
// Zero-lag moving average
zeroLagMA(float[] src, int SmoothPer, int BarsTaken)=>
float sum = 0
float sumw = 0
float weight = 0
float[] lwma1 = array.new<float>(BarsTaken, 0)
float[] output = array.new<float>(BarsTaken, 0)
for i = BarsTaken - 1 to 0
for k = 0 to SmoothPer - 1
if i + k >= 0 and i + k < BarsTaken - 1
weight := SmoothPer - k
sumw += weight
sum += weight * array.get(src, i + k)
if sumw != 0
array.set(lwma1, i, sum / sumw)
else
array.set(lwma1, i, 0)
sum := 0
sumw := 0
weight := 0
for i = 0 to BarsTaken - 1
for k = 0 to SmoothPer - 1
if i - k >= 0
weight := SmoothPer - k
sumw += weight
sum += weight * array.get(lwma1, i - k)
if sumw != 0
array.set(output, i, sum / sumw)
else
array.set(output, i, 0)
output
// Bartels probability
bartelsProb(int n, int N, Bvalues)=>
float AvgCoeffA = 0
float AvgCoeffB = 0
float AvgIndAmplit = 0
float AvgAmpl = 0
float ExptAmpl = 0
float ARatio = 0
float BP = 0
float[] teta = array.new<float>(n, 0)
float[] vsin = array.new<float>(n, 0)
float[] vcos = array.new<float>(n, 0)
float[] CoeffA = array.new<float>(N, 0)
float[] CoeffB = array.new<float>(N, 0)
float[] IndAmplit = array.new<float>(N, 0)
for i = 0 to n - 1
array.set(teta, i, 1.0 * (i + 1) / n * 2 * math.pi)
array.set(vsin, i, math.sin(array.get(teta, i)))
array.set(vcos, i, math.cos(array.get(teta, i)))
for t = 0 to N - 1
for i = 0 to n - 1
array.set(CoeffA, t, array.get(CoeffA, t) + array.get(vsin, i) * array.get(Bvalues, t * n + i))
array.set(CoeffB, t, array.get(CoeffB, t) + array.get(vcos, i) * array.get(Bvalues, t * n + i))
array.set(IndAmplit, t, math.pow(array.get(CoeffA, t), 2) + math.pow(array.get(CoeffB, t), 2))
for t = 0 to N - 1
AvgCoeffA += array.get(CoeffA, t)
AvgCoeffB += array.get(CoeffB, t)
AvgIndAmplit += array.get(IndAmplit, t)
AvgCoeffA := AvgCoeffA / N
AvgCoeffB := AvgCoeffB / N
AvgAmpl := math.sqrt(math.pow(AvgCoeffA, 2) + math.pow(AvgCoeffB, 2))
AvgIndAmplit := math.sqrt(AvgIndAmplit / N)
ExptAmpl := AvgIndAmplit / math.sqrt(1.0 * N)
ARatio := AvgAmpl / ExptAmpl
BP := 1 / math.exp(math.pow(ARatio, 2))
BP
// Detrend Logrithmic Zero-lag Regression
detrendLnZeroLagRegression(float[] src, int SmoothPer, int BarsTaken)=>
float[] RegValue = array.new<float>(BarsTaken, 0)
float[] output = array.new<float>(BarsTaken, 0)
float[] calcValues = zeroLagMA(src, SmoothPer, BarsTaken)
for i = 0 to BarsTaken - 1
array.set(calcValues, i, math.log( array.get(calcValues, i) ) * 100)
float val1 = 0
float val2 = 0
float val3 = 0
float sumy = 0
float sumx = 0
float sumxy = 0
float sumx2 = 0
for i = 0 to BarsTaken - 1
sumy += array.get(calcValues, i)
sumx += i
sumxy += i * array.get(calcValues, i)
sumx2 += i * i
val3 := sumx2 * BarsTaken - sumx * sumx
if val3 != 0.0
val2 := (sumxy * BarsTaken - sumx * sumy) / val3
val1 := (sumy - sumx * val2) / BarsTaken
for i = 0 to BarsTaken - 1
array.set(RegValue, i, val1 + val2 * i)
for i = 0 to BarsTaken - 1
array.set(output, i, array.get(calcValues, i) - array.get(RegValue, i))
output
// Bartels cycle significance test
bartelsCycleTest(float[] src, int G, float[] cyclebuffer, float[] BartelsProb, BartNoCycles, BartSmoothPer)=>
for k = 0 to G - 1
int bpi = math.round(array.get(cyclebuffer, k))
if bpi > 0
bval = detrendLnZeroLagRegression(src, BartSmoothPer, bpi * BartNoCycles)
array.set(BartelsProb, k, (1 - bartelsProb(bpi, BartNoCycles, bval)) * 100)
BartelsProb
// Goertzel function for spectral analysis
// src: input float array containing the data to be analyzed
// forBar: index of the starting bar in the data array
// samplesize: the number of samples per cycle
// per: the maximum number of cycles to analyze
// squaredAmp: a flag indicating whether to use the squared amplitude of the cycles
// useAddition: a flag indicating whether to use addition or subtraction for the wave equation
// useCosine: a flag indicating whether to use cosine or sine for the wave equation
// UseCycleStrength: a flag indicating whether to calculate the cycle strength
// WindowSizePast: the number of past bars to use for wave analysis
// FilterBartels: a flag indicating whether to use Bartel's test to filter out insignificant cycles
// BartNoCycles: the number of cycles to use for Bartel's test
// BartSmoothPer: the number of periods to smooth for Bartel's test
// BartSigLimit: the significance limit for Bartel's test
// SortBartels: a flag indicating whether to sort the cycles by significance
// goeWorkPast: a matrix used to store the past cycles for wave analysis
// cyclebuffer: an output array containing the cycles
// amplitudebuffer: an output array containing the amplitudes of the cycles
// phasebuffer: an output array containing the phases of the cycles
// cycleBartelsBuffer: an output array containing the Bartel's significance values of the cycles
goertzel(float[] src, simple int forBar, simple int samplesize, simple int per, simple bool squaredAmp, simple bool useAddition,
simple bool useCosine, simple bool UseCycleStrength, int WindowSizePast,
simple bool FilterBartels,simple int BartNoCycles, simple int BartSmoothPer, simple int BartSigLimit,
simple bool SortBartels, matrix<float> goeWorkPast, float[] cyclebuffer,
float[] amplitudebuffer, float[] phasebuffer, float[] cycleBartelsBuffer)=>
// Calculate the number of samples per cycle
int sample = 2 * per
// Initialize arrays
float[] goeWork1 = array.new_float(sample + 1, 0.)
float[] goeWork2 = array.new_float(sample + 1, 0.)
float[] goeWork3 = array.new_float(sample + 1, 0.)
float[] goeWork4 = array.new_float(sample + 1, 0.)
// Calculate the first two temporary values
float temp1 = array.get(src, forBar + sample - 1)
float temp2 = (array.get(src, forBar) - temp1) / (sample - 1)
float temp3 = 0.
// Fill goeWork4 and goeWork3 arrays
for k = sample - 1 to 1
float temp = array.get(src, forBar + k - 1) - (temp1 + temp2 * (sample - k))
array.set(goeWork4, k, temp)
array.set(goeWork3, k, 0.)
array.set(goeWork3, 0, 0)
// Calculate cycles
for k = 2 to per
float w = 0
float x = 0
float y = 0
float z = math.pow(k, -1)
temp1 := 2.0 * math.cos(2.0 * math.pi * z)
for i = sample to 1
w := temp1 * x - y + nz(array.get(goeWork4, i))
y := x
x := w
temp2 := x - y / 2.0 * temp1
if temp2 == 0.0
temp2 := 0.0000001
temp3 := y * math.sin(2.0 * math.pi * z)
// Cycle Strength = Cycle Amplitude / Cycle Length
// For trading, it is more important to know which cycle has the biggest influence to drive the price per bar,
// and not only which cycle has the highest amplitude
if UseCycleStrength
if squaredAmp
array.set(goeWork1, k, (math.pow(temp2, 2) + math.pow(temp3, 2)) / k)
else
array.set(goeWork1, k, (math.sqrt(math.pow(temp2, 2) + math.pow(temp3, 2))) / k)
array.set(goeWork2, k, math.atan(temp3 / temp2))
else
if squaredAmp
array.set(goeWork1, k, math.pow(temp2, 2) + math.pow(temp3, 2))
else
array.set(goeWork1, k, math.sqrt(math.pow(temp2, 2) + math.pow(temp3, 2)))
array.set(goeWork2, k, math.atan(temp3 / temp2))
// Adjust phase
if temp2 < 0.0
array.set(goeWork2, k, nz(array.get(goeWork2, k)) + math.pi)
else
if temp3 < 0.0
array.set(goeWork2, k, nz(array.get(goeWork2, k)) + 2.0 * math.pi)
for k = 3 to per - 1
if (nz(array.get(goeWork1, k)) > nz(array.get(goeWork1, k + 1)) and nz(array.get(goeWork1, k)) > nz(array.get(goeWork1, k - 1)))
array.set(goeWork3, k, k * math.pow(10, -4))
else
array.set(goeWork3, k, 0.0)
// extract cycles
int number_of_cycles = 0
for i = 0 to per + 1
if nz(array.get(goeWork3, i)) > 0.0
number_of_cycles += 1
array.set(cyclebuffer, number_of_cycles, math.round(10000.0 * array.get(goeWork3, i)))
array.set(amplitudebuffer, number_of_cycles, array.get(goeWork1, i))
array.set(phasebuffer, number_of_cycles, array.get(goeWork2, i))
// order cycles acc. largest amplitude or cycle strength
if number_of_cycles >= 1
for i = 1 to number_of_cycles - 1
for k = i + 1 to number_of_cycles
if array.get(amplitudebuffer, k) > array.get(amplitudebuffer, i)
y = array.get(amplitudebuffer, i)
w = array.get(cyclebuffer, i)
x = array.get(phasebuffer, i)
array.set(amplitudebuffer, i, array.get(amplitudebuffer, k))
array.set(cyclebuffer, i, array.get(cyclebuffer, k))
array.set(phasebuffer, i, array.get(phasebuffer, k))
array.set(amplitudebuffer, k, y)
array.set(cyclebuffer, k, w)
array.set(phasebuffer, k, x)
// Execute Bartels test for cycle significance
if FilterBartels
bartelsCycleTest(src, number_of_cycles, cyclebuffer, cycleBartelsBuffer, BartNoCycles, BartSmoothPer)
int no_Bcycles = 0
float v = 0
//Filter significant cycles
for i = 0 to number_of_cycles - 1
if array.get(cycleBartelsBuffer, i) > BartSigLimit
array.set(amplitudebuffer, no_Bcycles, array.get(amplitudebuffer, i))
array.set(cyclebuffer, no_Bcycles, array.get(cyclebuffer, i))
array.set(phasebuffer, no_Bcycles, array.get(phasebuffer, i))
array.set(cycleBartelsBuffer,no_Bcycles, array.get(cycleBartelsBuffer, i))
no_Bcycles += 1
number_of_cycles := no_Bcycles == 0 ? 0 : no_Bcycles
//Sort Bartels
if SortBartels and number_of_cycles >= 1
for i = 1 to number_of_cycles - 1
for k = i + 1 to number_of_cycles
if array.get(cycleBartelsBuffer, k) > array.get(cycleBartelsBuffer, i)
y = array.get(amplitudebuffer, i)
w = array.get(cyclebuffer, i)
x = array.get(phasebuffer, i)
v := array.get(cycleBartelsBuffer, i)
array.set(amplitudebuffer, i, array.get(amplitudebuffer, k))
array.set(cyclebuffer, i, array.get(cyclebuffer, k))
array.set(phasebuffer, i, array.get(phasebuffer, k))
array.set(cycleBartelsBuffer, i, array.get(cycleBartelsBuffer, k))
array.set(amplitudebuffer, k, y)
array.set(cyclebuffer, k, w)
array.set(phasebuffer, k, x)
array.set(cycleBartelsBuffer, k, v)
// calculate waves
for i = 1 to number_of_cycles
float amplitude = array.get(amplitudebuffer, i)
float phase = array.get(phasebuffer, i)
float cycle = array.get(cyclebuffer, i)
float sign = 1
if not useAddition
sign := -1
for k = 0 to WindowSizePast - 1
// add the wave to the matrix, using either sine or cosine function
if useCosine
matrix.set(goeWorkPast, k, i, amplitude * math.cos(phase + sign * k * 2.0 * math.pi / cycle))
else
matrix.set(goeWorkPast, k, i, amplitude * math.sin(phase + sign * k * 2.0 * math.pi / cycle))
// return the number of cycles found
number_of_cycles
// Hodrick-Prescott Filter
hodrickPrescottFilter(float[] src, float lamb, int per)=>
H1 = 0., H2 = 0., H3 = 0., H4 = 0., H5 = 0.,
HH1 = 0., HH2 = 0., HH3 = 0., HH5 = 0.
HB = 0., HC = 0., Z = 0.
float[] a = array.new<float>(per, 0.)
float[] b = array.new<float>(per, 0.)
float[] c = array.new<float>(per, 0.)
float[] output = array.new<float>(per, 0.)
for i = 0 to per - 1
array.set(output, i, array.get(src, i))
array.set(a, 0, 1.0 + lamb)
array.set(b, 0, -2.0 * lamb)
array.set(c, 0, lamb)
for i = 1 to per - 3
array.set(a, i, 6.0 * lamb + 1.0)
array.set(b, i, -4.0 * lamb)
array.set(c, i, lamb)
array.set(a, 1, 5.0 * lamb + 1)
array.set(a, per - 1, 1.0 + lamb)
array.set(a, per - 2, 5.0 * lamb + 1.0)
array.set(b, per - 2, -2.0 * lamb)
array.set(b, per - 1, 0.)
array.set(c, per - 2, 0.)
array.set(c, per - 1, 0.)
for i = 0 to per - 1
Z := array.get(a, i) - H4 * H1 - HH5 * HH2
if (Z == 0)
break
HB := array.get(b, i)
HH1 := H1
H1 := (HB - H4 * H2) / Z
array.set(b, i, H1)
HC := array.get(c, i)
HH2 := H2
H2 := HC / Z
array.set(c, i, H2)
array.set(a, i, (array.get(src, i) - HH3 * HH5 - H3 * H4) / Z)
HH3 := H3
H3 := array.get(a, i)
H4 := HB - H5 * HH1
HH5 := H5
H5 := HC
H2 := 0
H1 := array.get(a, per - 1)
array.set(output, per - 1, H1)
for i = per - 2 to 0
array.set(output, i, array.get(a, i) - array.get(b, i) * H1 - array.get(c, i) * H2)
H2 := H1
H1 := array.get(output, i)
output
// Detrending options
detrendCenteredMA(float[] src, int period1, int period2, int calcBars, string DTmethod)=>
if DTmethod == hpsmthdt
calcValues1 = hodrickPrescottFilter(src, 0.0625 / math.pow(math.sin(math.pi / period1), 4), calcBars)
calcValues2 = hodrickPrescottFilter(src, 0.0625 / math.pow(math.sin(math.pi / period2), 4), calcBars)
for i = 0 to calcBars - 1
array.set(src, i, array.get(calcValues1, i) - array.get(calcValues2, i))
if DTmethod == zlagsmthdt
calcValues1 = zeroLagMA(src, period1, calcBars)
calcValues2 = zeroLagMA(src, period2, calcBars)
for i = 0 to calcBars - 1
array.set(src, i, array.get(calcValues1, i) - array.get(calcValues2, i))
// BarToCalculate: This setting determines the starting bar for cycle calculations.
// Set it to 0 for the current (open) bar, or any number > 0 for closed bars
// (specific bar depends on the value entered).
// UseCosineForWaves: Choose between sine or cosine for wave reconstruction.
// Cosine is the preferred method for Goertzel calculations.
// UseAdditionForSteps: Determines how previous bar phases are reconstructed.
// If set to true, it adds steps to the current phase. If set to false, it
// subtracts steps from the current phase.
// UseSquaredAmp: Useful for adding many cycles, but may be misleading
// with 2 or 3 cycles. Recommended usage.
// UseTopCycles: Sorts by largest amplitude or cycle strength. Not necessarily the
// waves with the largest Bartels cycle significance, but often show significant values.
// Use cycle strength and Bartels >50 and select cycles with strength >1. Do not
// use more than 10 cycles.
// Subtract Noise: Only works when UseTopCycles < max. shown cycles
// Bartels Cycle Significance Test: Applied to every extracted Goertzel cycle.
// Smoothing: Original time series data can be smoothed with Hodrick
// Prescott filter or Absolutely No Lag LWMA.
// Detrending: Various methods are available, including Absolutely
// No Lag LWMA, a linear regression of the log-transformed
// smoothed time series data, and the HP algorithm.
// SampleSize: Calculated as BartNoCycles * MaxCycLength + BarToCalculate.
// WindowSizePast must be >= SampleSize.
// UseCycleStrength: Used as an alternative to amplitude before the Bartels test.
float src = input.source(close, "Source", group = "Basic Settings")
int MaxPer = input.int(120, "Max Period", minval = 2, group = "Basic Settings")
int WindowSizePast = input.int(100, "Window Size Past", group = "Basic Settings")
int StartAtCycle = input.int(1, "Start Cycle At", group = "Basic Settings")
int UseTopCycles = input.int(2, "Use Top Cycles", group = "Basic Settings")
int BarToCalculate = input.int(1, "Bar to Calculate", group = "Basic Settings")
int backbars = input.int(400, "Number of Bars to Render", group = "Basic Settings", tooltip ="How many bars to plot.The higher the number the slower the computation.")
string detrendornot = input.string(hpsmthdt, "Smoothing Mode", options = [none, hpsmth, zlagsmth, hpsmthdt, zlagsmthdt, logZlagRegression], group = "Source Price Detrending/Smoothing Settings")
int DT_ZLper1 = input.int(10, "Zero-lag Moving Average Fast Period", group = "Source Price Detrending Settings")
int DT_ZLper2 = input.int(40, "Zero-lag Moving Average Slow Period", group = "Source Price Detrending Settings")
int DT_HPper1 = input.int(20, "Hodrick-Prescott Filter Fast Period", group = "Source Price Detrending Settings")
int DT_HPper2 = input.int(80, "Hodrick-Prescott Filter Slow Period", group = "Source Price Detrending Settings")
int DT_RegZLsmoothPer = input.int(5, "Logarithmic Zero-lag Moving Average Regression Period", group = "Source Price Detrending Settings")
int HPsmoothPer = input.int(20, "Hodrick-Prescott Filter Period", group = "Source Price Smoothing Settings")
int ZLMAsmoothPer = input.int(10, "Zero-lag Moving Average Period", group = "Source Price Smoothing Settings")
bool FilterBartels = input.bool(false, "Filter Bartels", group = "Bartels Cycle Significance Settings")
int BartNoCycles = input.int(5, "Bartel Number of Cycles", group = "Bartels Cycle Significance Settings")
int BartSmoothPer = input.int(2, "Bartel Smoothing Period", group = "Bartels Cycle Significance Settings")
int BartSigLimit = input.int(50, "Bartel Signal Limit", group = "Bartels Cycle Significance Settings")
bool SortBartels = input.bool(false, "Sort Bartels", group = "Bartels Cycle Significance Settings")
bool squaredAmp = input.bool(true, "Squared Amplitude",group = "Miscellaneous Filter Settings")
bool useAddition = input.bool(false, "Use Addition", group = "Miscellaneous Filter Settings")
bool useCosine = input.bool(true, "Use Cosine", group = "Miscellaneous Filter Settings")
bool SubtractNoise = input.bool(false, "Subtract Noise", group = "Miscellaneous Filter Settings")
bool UseCycleStrength = input.bool(true, "Use Cycle Strength", group = "Miscellaneous Filter Settings")
colorbars = input.bool(true, "Color bars?", group = "UI Options")
showSigs = input.bool(true, "Show signals?", group = "UI Options")
plot(0, "Zero-line", color = color.gray)
float out = 0
if last_bar_index - bar_index < backbars
WindowSizePast := math.max(WindowSizePast, 2 * MaxPer)
matrix<float> goeWorkPast = matrix.new<float>(WindowSizePast, WindowSizePast, 0)
SampleSize = BartNoCycles * MaxPer + BarToCalculate
float[] cyclebuffer = array.new<float>(MaxPer + 1, 0)
float[] amplitudebuffer = array.new<float>(MaxPer + 1, 0)
float[] phasebuffer = array.new<float>(MaxPer + 1, 0)
float[] cycleBartelsBuffer = array.new<float>(MaxPer * 3, 0)
float[] srcVal = array.new<float>(SampleSize, 0)
for i = 0 to SampleSize - 1
array.set(srcVal, i, nz(src[i]))
if detrendornot == hpsmthdt
detrendCenteredMA(srcVal, DT_HPper1, DT_HPper2, SampleSize, detrendornot)
if detrendornot == zlagsmthdt
detrendCenteredMA(srcVal, DT_ZLper1, DT_ZLper2, SampleSize, detrendornot)
if detrendornot == logZlagRegression
srcVal := detrendLnZeroLagRegression(srcVal, DT_RegZLsmoothPer, SampleSize)
if detrendornot == hpsmth
srcVal := hodrickPrescottFilter(srcVal, 0.0625/math.pow(math.sin(math.pi / HPsmoothPer), 4), SampleSize)
if detrendornot == zlagsmth
srcVal := zeroLagMA(srcVal, ZLMAsmoothPer, SampleSize)
int number_of_cycles = goertzel(srcVal, BarToCalculate, SampleSize, MaxPer, squaredAmp, useAddition, useCosine, UseCycleStrength, WindowSizePast,
FilterBartels, BartNoCycles, BartSmoothPer, BartSigLimit,
SortBartels, goeWorkPast, cyclebuffer, amplitudebuffer, phasebuffer, cycleBartelsBuffer)
// epgoertzel = end pointed goertzel
float[] epgoertzel = array.new<float>(WindowSizePast + 1, 0)
// past bar calc. of composite wave
for i = 0 to WindowSizePast - 1
array.set(epgoertzel, i, 0)
for k = StartAtCycle to StartAtCycle + UseTopCycles - 1
array.set(epgoertzel, i, array.get(epgoertzel, i) + matrix.get(goeWorkPast, 0, k))
if SubtractNoise
if number_of_cycles >= 1
for k = StartAtCycle + UseTopCycles - 1 to number_of_cycles - 1
array.set(epgoertzel, i, array.get(epgoertzel, i) - matrix.get(goeWorkPast, 0, k))
out := array.get(epgoertzel, 0)
float middle = 0
color colorout = out > middle ? greencolor : out < middle ? redcolor : color.gray
plot(last_bar_index - bar_index < backbars ? out : na, "Goertzel Cycle Composite Wave", color = colorout, linewidth = 2)
barcolor(last_bar_index - bar_index < backbars and colorbars ? colorout : na)
goLong = ta.crossover(out, middle)
goShort = ta.crossunder(out, middle)
plotshape(showSigs and goLong, title = "Long", color = color.yellow, textcolor = color.yellow, text = "L", style = shape.triangleup, location = location.bottom, size = size.auto)
plotshape(showSigs and goShort, title = "Short", color = color.fuchsia, textcolor = color.fuchsia, text = "S", style = shape.triangledown, location = location.top, size = size.auto)
alertcondition(goLong, title = "Long", message = "Goertzel Cycle Composite Wave [Loxx]: Long\nSymbol: {{ticker}}\nPrice: {{close}}")
alertcondition(goShort, title = "Short", message = "Goertzel Cycle Composite Wave [Loxx]: Short\nSymbol: {{ticker}}\nPrice: {{close}}") |
Probability Envelopes (PBE) | https://www.tradingview.com/script/7zhoyAJQ-Probability-Envelopes-PBE/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 60 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Probability Envelopes", "PBE", precision = 3, overlay = true, max_bars_back = 100)
useLogReturns = input(false, title="Use Log Returns")
multiplier = input.float(2, "Multiplier", 0.05, 10, 0.05)
filter = input.int(6, "Smoothing Length", 1, 1000)
ripple = input.float(0.05, "Ripple", 0.01, 0.99, 0.01)
style = input.bool(false, "Filter Style")
rounding = input.int(6, "Precision")
max_back = input.int(5000, "Max Bars Back", 0, tooltip = "Adjust this to limit the indicator's look back period. Try to minimize this if you can.")
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, int len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
// Chebyshev Type II Moving Average
chebyshevII(float src, int len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / ripple))
b := sinh(1 / len * asinh(ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1], src)
chebyshev
// adjust the ripple value based on your requirement (between 0 and 1)
chebyshev(float src, int length, float ripple, bool style) =>
not style ?
chebyshevI(src, length, ripple) :
chebyshevII(src, length, ripple)
percent(a, b)=>
((a-b)/b) * 100
log_return(a, b) =>
math.log(a / b)
ema(float source = close, float length = 9)=>
alpha = 2 / (length + 1)
var float smoothed = na
smoothed := alpha * source + (1 - alpha) * nz(smoothed[1])
addPercentage(number, percentage) =>
result = number * (1 + percentage / 100)
result
addLogReturn(number, log_return) =>
result = number * math.exp(log_return)
result
add(a, b) =>
switch useLogReturns
true => addLogReturn(a, b)
false => addPercentage(a, b)
var movement_size_green = array.new<float>(1)
var count_green = array.new<int>(1)
var movement_size_red = array.new<float>(1)
var count_red = array.new<int>(1)
var float expected_mean = 0
var float mean_green = 0
var float std_dev_green = 0
var float mean_red = 0
var float std_dev_red = 0
var float expected_high_price = 0
var float expected_low_price = 0
if bar_index > max_back
change = useLogReturns ? math.round(log_return(close, close[1]), rounding) : math.round(percent(close, close[1]), rounding)
if close > open
if array.includes(movement_size_green, change)
index = array.indexof(movement_size_green, change)
array.set(count_green, index, array.get(count_green, index) + 1)
else
array.push(movement_size_green, change)
array.push(count_green, 1)
if close < open
if array.includes(movement_size_red, change)
index = array.indexof(movement_size_red, change)
array.set(count_red, index, array.get(count_red, index) + 1)
else
array.push(movement_size_red, change)
array.push(count_red, 1)
probability_green = array.new<float>(array.size(count_green))
probability_red = array.new<float>(array.size(count_red))
count_green_sum = array.sum(count_green)
count_red_sum = array.sum(count_red)
for i = 0 to array.size(count_green) - 1
probability = array.get(count_green, i) / count_green_sum * 100
array.set(probability_green, i, probability)
for i = 0 to array.size(count_red) - 1
probability = array.get(count_red, i) / count_red_sum * 100
array.set(probability_red, i, probability)
mean_green := array.avg(movement_size_green)
mean_red := array.avg(movement_size_red)
squared_diff_green = array.new<float>(array.size(movement_size_green))
squared_diff_red = array.new<float>(array.size(movement_size_red))
for i = 0 to array.size(movement_size_green) - 1
diff = array.get(movement_size_green, i) - mean_green
array.set(squared_diff_green, i, diff * diff)
for i = 0 to array.size(movement_size_red) - 1
diff = array.get(movement_size_red, i) - mean_red
array.set(squared_diff_red, i, diff * diff)
variance_green = array.avg(squared_diff_green)
variance_red = array.avg(squared_diff_red)
std_dev_green := math.sqrt(variance_green)
std_dev_red := math.sqrt(variance_red)
// Calculate the expected green and red movements
expected_green_movement = 0.0
expected_red_movement = 0.0
for i = 0 to array.size(movement_size_green) - 1
expected_green_movement := nz(expected_green_movement[1]) + array.get(movement_size_green, i) * array.get(probability_green, i) / 100
for i = 0 to array.size(movement_size_red) - 1
expected_red_movement := nz(expected_red_movement[1]) + array.get(movement_size_red, i) * array.get(probability_red, i) / 100
// Calculate the total expected movement (weighted average)
expected_mean_movement = (count_green_sum * expected_green_movement + count_red_sum * expected_red_movement) / (count_green_sum + count_red_sum)
// Apply the expected mean movement to the current open price
expected_mean := chebyshev(close + expected_mean_movement * (useLogReturns ? 1 : 0.01), filter, ripple, style)
plot(expected_mean, "Expected Mean", color=color.orange)
plot(add(expected_mean, mean_green + std_dev_green * multiplier), title="Lower Green Band", color=color.green)
plot(add(expected_mean, mean_red - std_dev_red * multiplier), title="Upper Red Band", color=color.red)
|
AI-Bank-Nifty Tech Analysis | https://www.tradingview.com/script/j8dRWBK7-AI-Bank-Nifty-Tech-Analysis/ | chhagansinghmeena | https://www.tradingview.com/u/chhagansinghmeena/ | 503 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © chhagansinghmeena
//@version=5
indicator("AI-Bank-Nifty Tech Analysis [CSM]", shorttitle = "CSM BankNifty & Nifty", overlay = true)
import chhagansinghmeena/BankNifty_CSM/16 as CSM
optionScript = input.string(title = "Data Analysis Display", defval = "BankNifty", options = ['BankNifty', 'Nifty', 'Current Stock'],tooltip = "When BankNifty or Nifty is selected, the current stock's result will be displayed at the bottom of the table. It will update as the selected stock changes on the chart.")
showCandles = input.bool(title = "Smart AI Candle Detection", defval = false,tooltip = "This tool checks the candles to determine bullish or bearish trends based on CPMA (Conceptive Price Moving Average).")
addSmoothing = input.bool(title = 'Smooth CPMA', defval = false, tooltip = 'By enabling this the CPMA smoothed and represent on chart')
enableTblHide = input.bool(title = "Table Hide", defval = false,group='Table Position/Style')
dash_loc = input.session("Top Right","Bank Dashboard Location" ,options=["Top Right","Bottom Right","Top Left","Bottom Left", "Middle Right","Bottom Center"] ,group='Table Position/Style')
text_size = input.session('Small',"Dashboard Size" ,options=["Tiny","Small","Normal","Large"] ,group='Table Position/Style')
cell_up = input(#4caf50,'Bullish' ,group='Table Cell Color', inline = 'Bullish')
cell_dn = input(#FF5252,'Bearish' ,group='Table Cell Color', inline = 'Bullish')
cell_netural = input(color.gray,'Neutral' ,group='Table Cell Color', inline = 'Bullish')
txt_col = input(color.white,'Text Color' ,group='Table Cell Color',inline = 'Text Color' )
frm_col = input(color.black,'Frame Color' ,group='Table Cell Color', inline = 'Text Color')
cell_transp = 10
filterNifty = optionScript == "BankNifty" ? false : true
enableForSpecific = optionScript == "Current Stock" ? true : false
t1 = filterNifty ? "NSE:RELIANCE" : "NSE:HDFCBANK"
t2 = filterNifty ? "NSE:HDFCBANK" : "NSE:ICICIBANK"
t3 = filterNifty ? "NSE:INFY" : "NSE:KOTAKBANK"
t4 = filterNifty ? "NSE:HDFC" : "NSE:AXISBANK"
t5 = filterNifty ? "NSE:ICICIBANK" : "NSE:SBIN"
t6 = filterNifty ? "NSE:TCS" : "NSE:INDUSINDBK"
t7 = filterNifty ? "NSE:KOTAKBANK" : "NSE:PNB"
t8 = filterNifty ? "NSE:HINDUNILVR": "NSE:BANDHANBNK"
t9 = filterNifty ? "NSE:BAJFINANCE" : "NSE:FEDERALBNK"
t10 = filterNifty ? "NSE:SBIN" : "NSE:IDFCFIRSTB"
t11 = syminfo.tickerid
// Add India VIX and SGX Nifty
t12 = "NSE:INDIAVIX"
t13 = filterNifty ? "SGX_DLY:IN1!" : "TVC:DJI"
/// -------------- Table Start -------------------
var table_position = dash_loc == 'Top Left' ? position.top_left :
dash_loc == 'Bottom Left' ? position.bottom_left :
dash_loc == 'Middle Right' ? position.middle_right :
dash_loc == 'Bottom Center' ? position.bottom_center :
dash_loc == 'Top Right' ? position.top_right : position.bottom_right
var table_text_size = text_size == 'Tiny' ? size.tiny :
text_size == 'Small' ? size.small :
text_size == 'Normal' ? size.normal : size.large
///// -- Table Inputs
max = 120
min = 10
var t = table.new(table_position,19,math.abs(max-min)+2,
bgcolor =color.rgb(86, 89, 101),
frame_color=frm_col,
frame_width=1,
border_color=frm_col,
border_width=1)
cpmaAVG = close
get_BankComponent_Details(symbol)=>
[lastClosePrice, lastOpenPrice] = request.security(symbol, "1D", [close[1],open[1]])
[openPrice,closePrice,highPrice,hl2Price,lowPrice,hlc3Price,OHLC4Price,hlcc4Price, vol] = request.security(symbol, timeframe.period, [open,close,high,hl2,low, hlc3, ohlc4,hlcc4,volume])
filterBy = enableForSpecific ? syminfo.tickerid : filterNifty ? "NSE:NIFTY" : "NSE:BANKNIFTY"
[bankNiftyClose, prevBankNiftyClose] = request.security(filterBy, "1D", [close,close[1]])
priceVal = CSM.CSM_CPMA(length = 14 ,price = closePrice,HL2 = hl2Price, Open = openPrice , High = highPrice, Low = lowPrice, OHLC4 = OHLC4Price, HLC3 = hlc3Price, HLCC4 = hlcc4Price)
csm_cpmaBuy = closePrice > priceVal
csm_cpmaSell = closePrice < priceVal
csm_cpmaBuy_text = csm_cpmaBuy ? 'Buy' : 'Sell'
index_change = (bankNiftyClose / prevBankNiftyClose) -1
stock_change = (closePrice / lastClosePrice) - 1
w_r_t_Result = stock_change > 0 and csm_cpmaBuy ? 'Buy' : stock_change < 0 and csm_cpmaSell ? 'Sell' : 'Neutral'
[ts1, ts1Chng, ts1p, VWAPColor, VWAPText, trend, BuySell, ADXColor, ADXText, RSIColor, RSIText, MFIColor, MFIText, AllG_Color, AllG_Text, MACD_Color, MACDText, FARMA_Color, FARMAText, ST_Color_21, ST_Text_21, ST_Color_14, ST_Text_14, ST_Color_10, ST_Text_10, RS_Text, RS_Color] = CSM.getLtp_N_Chang(openPrice, closePrice , highPrice , hl2Price, lowPrice, hlc3Price, lastClosePrice, bankNiftyClose)
// trendUp = VWAPText == 'Buy' and csm_cpmaBuy and MACDText == 'Buy' and FARMAText == 'Buy' ? true : false
// trendDwn = VWAPText == 'Sell' and csm_cpmaSell and MACDText == 'Sell' and FARMAText == 'Sell' ? true : false
w_r_t_Result := w_r_t_Result == 'Buy' and csm_cpmaBuy ? 'Buy' : w_r_t_Result == 'Sell' and csm_cpmaSell ? 'Sell' : 'Neutral'
[w_r_t_Result,ts1, ts1Chng, vol, VWAPColor, VWAPText, csm_cpmaBuy, csm_cpmaBuy_text, ADXColor, ADXText, RSIColor, RSIText, MFIColor, MFIText, AllG_Color, AllG_Text, MACD_Color, MACDText, FARMA_Color, FARMAText, ST_Color_21, ST_Text_21, ST_Color_14, ST_Text_14, ST_Color_10, ST_Text_10, RS_Text, RS_Color, priceVal]
//Confirmation From RSI, MFI, FRAMA, MACD and VWAP
[w_r_t_Result, ltp, ltpCng, ltpPercChng, srcpVwap, srcpVWAPText, srcpCPMA, srcpCPMAtext, srcpADXColor, srcpADXText, srcpRSIColor, srcpRSIText, srcpMFIColor, srcpMFIText, srcpAllG_Color, srcpAllG_Text, srcpMACD_Color, srcpMACDText, srcpFARMA_Color, srcpFARMAText, srcpST_Color_21, srcpST_Text_21, srcpST_Color_14, srcpST_Text_14, srcpST_Color_10, srcpST_Text_10, srcpRS_Text, srcpRS_Color, CPMA1] = get_BankComponent_Details(syminfo.tickerid)
trendUp = srcpVWAPText == 'Buy' and srcpCPMAtext == 'Buy' and srcpMACDText == 'Buy' and srcpFARMAText == 'Buy' ? true : false
trendDwn = srcpVWAPText == 'Sell' and srcpCPMAtext == 'Sell' and srcpMACDText == 'Sell' and srcpFARMAText == 'Sell' ? true : false
CPMA_TrendUP = close > CPMA1
CPMA_TrendDwn = close < CPMA1
bullishCandle = CSM.candlepatternbullish() and CPMA_TrendUP[1]
bearishCandle = CSM.candlepatternbearish() and CPMA_TrendDwn[1]
Signal = 0
Signal := bullishCandle ? 1 : bearishCandle ? -1 : nz(Signal[1])
isDifferentSignalType = ta.change(Signal)
//plot on chart
plotshape(showCandles and bullishCandle and isDifferentSignalType , title="Bullish Candle", location=location.belowbar, style=shape.labelup, size=size.tiny, color=color.new(color.green, 0), textcolor=color.new(color.white, 0),text = "AI Bullish")
plotshape(showCandles and bearishCandle and isDifferentSignalType , title="Bearish Candle", location=location.abovebar, style=shape.labeldown, size=size.tiny, color=color.new(color.red, 0), textcolor=color.new(color.white, 0), text="AI Bearish")
CPMAcolor = close > CPMA1 ? color.green : close < CPMA1 ? color.red : color.white
//Thanks Lux Algo For radient approach
//Smoothing Idea took from LUX ALGO 'AM&MA'
[src_Sum, colorCPMA] = CSM.getGradientColor(isFirstbar = barstate.isfirst, src = CPMA1, length = 14, isSmoothed = addSmoothing)
//plot(CPMA1, color=CPMAcolor, linewidth=2, title="CPMA")
plot(src_Sum, color=colorCPMA, linewidth=2, title="CPMA")
// Get Bank Nifty data
//----------------HDFC
[w_r_t_Result1, ts1, ts1Chng, ts1p, VWAPColor, VWAPText, trend, BuySell, ADXColor, ADXText, RSIColor, RSIText, MFIColor, MFIText, AllG_Color, AllG_Text, MACD_Color, MACDText, FARMA_Color, FARMAText, ST_Color_21, ST_Text_21, ST_Color_14, ST_Text_14, ST_Color_10, ST_Text_10, RS_Text, RS_Color,CPMA] = get_BankComponent_Details(t1)
//----------------ICIC
[w_r_t_Result2, ts2, ts2Chng, ts2p, VWAPColor2, VWAPText2,trend2, BuySell2, ADXColor2, ADXText2, RSIColor2, RSIText2, MFIColor2, MFIText2, AllG_Color2, AllG_Text2, MACD_Color2, MACDText2, FARMA_Color2, FARMAText2, ST_Color_212, ST_Text_212, ST_Color_142, ST_Text_142, ST_Color_102, ST_Text_102, RS_Text2, RS_Color2,CPMA2] = get_BankComponent_Details(t2)
//----------------KOTAK
[w_r_t_Result3, ts3, ts3Chng, ts3p, VWAPColor3, VWAPText3, trend3, BuySell3, ADXColor3, ADXText3, RSIColor3, RSIText3, MFIColor3, MFIText3, AllG_Color3, AllG_Text3, MACD_Color3, MACDText3, FARMA_Color3, FARMAText3, ST_Color_213, ST_Text_213, ST_Color_143, ST_Text_143, ST_Color_103, ST_Text_103, RS_Text3, RS_Color3, CPMA3] = get_BankComponent_Details(t3)
//----------------SBIN
[w_r_t_Result4, ts4, ts4Chng, ts4p, VWAPColor4, VWAPText4, trend4, BuySell4, ADXColor4, ADXText4, RSIColor4, RSIText4, MFIColor4, MFIText4, AllG_Color4, AllG_Text4, MACD_Color4, MACDText4, FARMA_Color4, FARMAText4, ST_Color_214, ST_Text_214, ST_Color_144, ST_Text_144, ST_Color_104, ST_Text_104, RS_Text4, RS_Color4, CPMA4] = get_BankComponent_Details(t4)
//----------------AXIS
[w_r_t_Result5, ts5, ts5Chng, ts5p, VWAPColor5, VWAPText5, trend5, BuySell5, ADXColor5, ADXText5, RSIColor5, RSIText5, MFIColor5, MFIText5, AllG_Color5, AllG_Text5, MACD_Color5, MACDText5, FARMA_Color5, FARMAText5,ST_Color_215, ST_Text_215, ST_Color_145, ST_Text_145, ST_Color_105, ST_Text_105, RS_Text5, RS_Color5, CPMA5] = get_BankComponent_Details(t5)
//----------------BANKNIFTY
[w_r_t_Result6, ts6, ts6Chng, ts6p, VWAPColor6, VWAPText6, trend6, BuySell6, ADXColor6, ADXText6, RSIColor6, RSIText6, MFIColor6, MFIText6, AllG_Color6, AllG_Text6, MACD_Color6, MACDText6, FARMA_Color6, FARMAText6, ST_Color_216, ST_Text_216, ST_Color_146, ST_Text_146, ST_Color_106, ST_Text_106, RS_Text6, RS_Color6, CPMA6] = get_BankComponent_Details(t6)
//----------------HDFC
[w_r_t_Result7, ts7, ts7Chng, ts7p, VWAPColor7, VWAPText7, trend7, BuySell7, ADXColor7, ADXText7, RSIColor7, RSIText7, MFIColor7, MFIText7, AllG_Color7, AllG_Text7, MACD_Color7, MACDText7, FARMA_Color7, FARMAText7,ST_Color_217, ST_Text_217, ST_Color_147, ST_Text_147, ST_Color_107, ST_Text_107, RS_Text7, RS_Color7, CPMA7] = get_BankComponent_Details(t7)
//----------------RELIANCE
[w_r_t_Result8, ts8, ts8Chng, ts8p, VWAPColor8, VWAPText8, trend8, BuySell8, ADXColor8, ADXText8, RSIColor8, RSIText8, MFIColor8, MFIText8, AllG_Color8, AllG_Text8, MACD_Color8, MACDText8, FARMA_Color8, FARMAText8, ST_Color_218, ST_Text_218, ST_Color_148, ST_Text_148, ST_Color_108, ST_Text_108, RS_Text8, RS_Color8, CPMA8] = get_BankComponent_Details(t8)
//----------------TCS
[w_r_t_Result9, ts9, ts9Chng, ts9p, VWAPColor9, VWAPText9, trend9, BuySell9, ADXColor9, ADXText9, RSIColor9, RSIText9, MFIColor9, MFIText9, AllG_Color9, AllG_Text9, MACD_Color9, MACDText9, FARMA_Color9, FARMAText9, ST_Color_219, ST_Text_219, ST_Color_149, ST_Text_149, ST_Color_109, ST_Text_109, RS_Text9, RS_Color9, CPMA9] = get_BankComponent_Details(t9)
//----------------INFY
[w_r_t_Result10, ts10, ts10Chng, ts10p, VWAPColor10, VWAPText10, trend10, BuySell10, ADXColor10, ADXText10, RSIColor10, RSIText10, MFIColor10, MFIText10, AllG_Color10, AllG_Text10, MACD_Color10, MACDText10, FARMA_Color10, FARMAText10, ST_Color_2110, ST_Text_2110, ST_Color_1410, ST_Text_1410, ST_Color_1010, ST_Text_1010, RS_Text10, RS_Color10, CPMA10] = get_BankComponent_Details(t10)
//----------------Fedral
[w_r_t_Result11, ts11, ts11Chng, ts11p, VWAPColor11, VWAPText11, trend11, BuySell11, ADXColor11, ADXText11, RSIColor11, RSIText11, MFIColor11, MFIText11, AllG_Color11, AllG_Text11, MACD_Color11, MACDText11, FARMA_Color11, FARMAText11, ST_Color_2111, ST_Text_2111, ST_Color_1411, ST_Text_1411, ST_Color_1011, ST_Text_1011, RS_Text11, RS_Color11, CPMA11] = get_BankComponent_Details(t11)
//----------------India VIX
[w_r_t_Result12, ts12, ts12Chng, ts12p, VWAPColor12, VWAPText12, trend12, BuySell12, ADXColor12, ADXText12, RSIColor12, RSIText12, MFIColor12, MFIText12, AllG_Color12, AllG_Text12, MACD_Color12, MACDText12, FARMA_Color12, FARMAText12, ST_Color_2112, ST_Text_2112, ST_Color_1412, ST_Text_1412, ST_Color_1212, ST_Text_1212, RS_Text12, RS_Color12, CPMA12] = get_BankComponent_Details(t12)
//----------------DOW
[w_r_t_Result13, ts13, ts13Chng, ts13p, VWAPColor13, VWAPText13, trend13, BuySell13, ADXColor13, ADXText13, RSIColor13, RSIText13, MFIColor13, MFIText13, AllG_Color13, AllG_Text13, MACD_Color13, MACDText13, FARMA_Color13, FARMAText13, ST_Color_2113, ST_Text_2113, ST_Color_1413, ST_Text_1413, ST_Color_1313, ST_Text_1313, RS_Text13, RS_Color13, CPMA13] = get_BankComponent_Details(t13)
funcUpdateTableCells(forRow,w_r_t_Result, scrpName, ts1, ts1Chng, ts1p, VWAPColor, VWAPText, trend, BuySell, ADXColor, ADXText, RSIColor, RSIText, MFIColor, MFIText, AllG_Color, AllG_Text, MACD_Color, MACDText, FARMA_Color, FARMAText, ST_Color_21, ST_Text_21, ST_Color_14, ST_Text_14, ST_Color_10, ST_Text_10, RS_Text, RS_Color)=>
table.cell(t,1,forRow,str.tostring(w_r_t_Result),text_color=txt_col,text_size=table_text_size, bgcolor=color.new( w_r_t_Result == 'Buy' ? cell_up : w_r_t_Result == 'Sell' ? cell_dn : cell_netural,cell_transp))
table.cell(t,2,forRow, str.replace_all(scrpName, 'NSE:', ''),text_color= forRow == 1 or forRow ==2 ? #d3a9fe : forRow == 13 ? #bed510 : #4caf50,text_size=table_text_size,bgcolor=color.black)
table.cell(t,3,forRow, str.tostring(ts1) ,text_color=color.new(ts1p >= 0 ? cell_up : cell_dn ,cell_transp),text_size=table_text_size, bgcolor=color.black)
table.cell(t,4,forRow, str.tostring(ts1Chng, '#.##'),text_color=color.new(ts1Chng >= 0 ? cell_up : cell_dn ,cell_transp),text_size=table_text_size, bgcolor=color.black)
table.cell(t,5,forRow, forRow == 1 or forRow ==2 ? ' - ' : str.tostring(ts1p),text_color = forRow == 1 or forRow ==2 ? color.white : color.new(ts1p >= 0 ? txt_col : cell_netural, cell_transp),text_size=table_text_size, bgcolor= forRow == 1 or forRow ==2 ? cell_netural : color.new(ts1Chng >= 0 ? cell_up : cell_dn ,cell_transp) )
table.cell(t,6,forRow,str.tostring(AllG_Text),text_color=txt_col,text_size=table_text_size, bgcolor= AllG_Color)
table.cell(t,7,forRow,str.tostring(VWAPText),text_color=txt_col,text_size=table_text_size, bgcolor= VWAPColor)
table.cell(t,8,forRow,str.tostring(BuySell),text_color=txt_col,text_size=table_text_size, bgcolor=color.new( trend ? cell_up : cell_dn ,cell_transp))
table.cell(t,9,forRow,str.tostring(ADXText),text_color=txt_col,text_size=table_text_size, bgcolor= ADXColor)
table.cell(t,10,forRow,str.tostring(RSIText),text_color=txt_col,text_size=table_text_size, bgcolor= RSIColor)
table.cell(t,11,forRow,str.tostring(MFIText),text_color=txt_col,text_size=table_text_size, bgcolor= MFIColor)
table.cell(t,12,forRow,str.tostring(MACDText),text_color=txt_col,text_size=table_text_size, bgcolor= MACD_Color)
table.cell(t,13,forRow,str.tostring(FARMAText),text_color=txt_col,text_size=table_text_size, bgcolor= FARMA_Color)
table.cell(t,14,forRow,str.tostring(ST_Text_21),text_color=txt_col,text_size=table_text_size, bgcolor= ST_Color_21)
table.cell(t,15,forRow,str.tostring(ST_Text_14),text_color=txt_col,text_size=table_text_size, bgcolor= ST_Color_14)
table.cell(t,16,forRow,str.tostring(ST_Text_10),text_color=txt_col,text_size=table_text_size, bgcolor= ST_Color_10)
// table.cell(t,17,forRow,str.tostring(RS_Text),text_color=txt_col,text_size=table_text_size, bgcolor= RS_Color)
Update = true
maxStockCount = enableForSpecific ? 1 : 13
//========== Table Logic Start
if (barstate.islast and not enableTblHide)
table.cell(t,1,0,'RWR:'+timeframe.period,text_color=txt_col,text_size=table_text_size)
table.cell(t,2,0,'Symbol',text_color=txt_col,text_size=table_text_size)
table.cell(t,3,0,'LTP',text_color=txt_col,text_size=table_text_size)
table.cell(t,4,0,'Chng',text_color=txt_col,text_size=table_text_size)
table.cell(t,5,0,'Vol',text_color=txt_col,text_size=table_text_size)
table.cell(t,6,0,'Alligator',text_color=txt_col,text_size=table_text_size)
table.cell(t,7,0,'VWAP',text_color=txt_col,text_size=table_text_size)
table.cell(t,8,0,'CPMA',text_color=#c89cef,text_size=table_text_size)
table.cell(t,9,0,'ADX',text_color=txt_col,text_size=table_text_size)
table.cell(t,10,0,'RSI 30/70',text_color=txt_col,text_size=table_text_size)
table.cell(t,11,0,'MFI 20/80',text_color=txt_col,text_size=table_text_size)
table.cell(t,12,0,'MACD',text_color=txt_col,text_size=table_text_size)
table.cell(t,13,0,'FARMA',text_color=txt_col,text_size=table_text_size)
table.cell(t,14,0,'ST 21-1',text_color=txt_col,text_size=table_text_size)
table.cell(t,15,0,'ST 14-2',text_color=txt_col,text_size=table_text_size)
table.cell(t,16,0,'ST 10-3',text_color=txt_col,text_size=table_text_size)
// table.cell(t,17,0,'RS',text_color=txt_col,text_size=table_text_size)
for i = 1 to maxStockCount by 1
if maxStockCount == 1 and enableForSpecific
funcUpdateTableCells(i,w_r_t_Result11, t11,ts11, ts11Chng, ts11p, VWAPColor11, VWAPText11, trend11, BuySell11, ADXColor11, ADXText11, RSIColor11, RSIText11, MFIColor11, MFIText11, AllG_Color11, AllG_Text11, MACD_Color11, MACDText11, FARMA_Color11, FARMAText11, ST_Color_2111, ST_Text_2111, ST_Color_1411, ST_Text_1411, ST_Color_1011, ST_Text_1011, RS_Text11, RS_Color11)
else
switch
i == 1 => funcUpdateTableCells(i,w_r_t_Result12, 'INDIAVIX', ts12, ts12Chng, ts12p, VWAPColor12, VWAPText12, trend12, BuySell12, ADXColor12, ADXText12, RSIColor12, RSIText12, MFIColor12, MFIText12, AllG_Color12, AllG_Text12, MACD_Color12, MACDText12, FARMA_Color12, FARMAText12, ST_Color_2112, ST_Text_2112, ST_Color_1412, ST_Text_1412, ST_Color_1212, ST_Text_1212, RS_Text12, RS_Color12)
i == 2 => funcUpdateTableCells(i,w_r_t_Result13, filterNifty ? 'SGX Nifty' : 'DJIA Futures', ts13, ts13Chng, ts13p, VWAPColor13, VWAPText13, trend13, BuySell13, ADXColor13, ADXText13, RSIColor13, RSIText13, MFIColor13, MFIText13, AllG_Color13, AllG_Text13, MACD_Color13, MACDText13, FARMA_Color13, FARMAText13, ST_Color_2113, ST_Text_2113, ST_Color_1413, ST_Text_1413, ST_Color_1313, ST_Text_1313, RS_Text13, RS_Color13)
i == 3 => funcUpdateTableCells(i,w_r_t_Result1, t1, ts1, ts1Chng, ts1p, VWAPColor, VWAPText, trend, BuySell, ADXColor, ADXText, RSIColor, RSIText, MFIColor, MFIText, AllG_Color, AllG_Text, MACD_Color, MACDText, FARMA_Color, FARMAText, ST_Color_21, ST_Text_21, ST_Color_14, ST_Text_14, ST_Color_10, ST_Text_10, RS_Text, RS_Color)
i == 4 => funcUpdateTableCells(i,w_r_t_Result2, t2, ts2, ts2Chng, ts2p, VWAPColor2, VWAPText2,trend2, BuySell2, ADXColor2, ADXText2, RSIColor2, RSIText2, MFIColor2, MFIText2, AllG_Color2, AllG_Text2, MACD_Color2, MACDText2, FARMA_Color2, FARMAText2, ST_Color_212, ST_Text_212, ST_Color_142, ST_Text_142, ST_Color_102, ST_Text_102, RS_Text2, RS_Color2)
i == 5 => funcUpdateTableCells(i,w_r_t_Result3, t3, ts3, ts3Chng, ts3p, VWAPColor3, VWAPText3, trend3, BuySell3, ADXColor3, ADXText3, RSIColor3, RSIText3, MFIColor3, MFIText3, AllG_Color3, AllG_Text3, MACD_Color3, MACDText3, FARMA_Color3, FARMAText3, ST_Color_213, ST_Text_213, ST_Color_143, ST_Text_143, ST_Color_103, ST_Text_103, RS_Text3, RS_Color3)
i == 6 => funcUpdateTableCells(i,w_r_t_Result4, t4, ts4, ts4Chng, ts4p, VWAPColor4, VWAPText4, trend4, BuySell4, ADXColor4, ADXText4, RSIColor4, RSIText4, MFIColor4, MFIText4, AllG_Color4, AllG_Text4, MACD_Color4, MACDText4, FARMA_Color4, FARMAText4, ST_Color_214, ST_Text_214, ST_Color_144, ST_Text_144, ST_Color_104, ST_Text_104, RS_Text4, RS_Color4)
i == 7 => funcUpdateTableCells(i,w_r_t_Result5, t5, ts5, ts5Chng, ts5p, VWAPColor5, VWAPText5, trend5, BuySell5, ADXColor5, ADXText5, RSIColor5, RSIText5, MFIColor5, MFIText5, AllG_Color5, AllG_Text5, MACD_Color5, MACDText5, FARMA_Color5, FARMAText5,ST_Color_215, ST_Text_215, ST_Color_145, ST_Text_145, ST_Color_105, ST_Text_105, RS_Text5, RS_Color5)
i == 8 => funcUpdateTableCells(i,w_r_t_Result6, t6, ts6, ts6Chng, ts6p, VWAPColor6, VWAPText6, trend6, BuySell6, ADXColor6, ADXText6, RSIColor6, RSIText6, MFIColor6, MFIText6, AllG_Color6, AllG_Text6, MACD_Color6, MACDText6, FARMA_Color6, FARMAText6, ST_Color_216, ST_Text_216, ST_Color_146, ST_Text_146, ST_Color_106, ST_Text_106, RS_Text6, RS_Color6)
i == 9 => funcUpdateTableCells(i,w_r_t_Result7, t7, ts7, ts7Chng, ts7p, VWAPColor7, VWAPText7, trend7, BuySell7, ADXColor7, ADXText7, RSIColor7, RSIText7, MFIColor7, MFIText7, AllG_Color7, AllG_Text7, MACD_Color7, MACDText7, FARMA_Color7, FARMAText7,ST_Color_217, ST_Text_217, ST_Color_147, ST_Text_147, ST_Color_107, ST_Text_107, RS_Text7, RS_Color7)
i == 10 => funcUpdateTableCells(i,w_r_t_Result8, t8, ts8, ts8Chng, ts8p, VWAPColor8, VWAPText8, trend8, BuySell8, ADXColor8, ADXText8, RSIColor8, RSIText8, MFIColor8, MFIText8, AllG_Color8, AllG_Text8, MACD_Color8, MACDText8, FARMA_Color8, FARMAText8, ST_Color_218, ST_Text_218, ST_Color_148, ST_Text_148, ST_Color_108, ST_Text_108, RS_Text8, RS_Color8)
i == 11 => funcUpdateTableCells(i,w_r_t_Result9, t9, ts9, ts9Chng, ts9p, VWAPColor9, VWAPText9, trend9, BuySell9, ADXColor9, ADXText9, RSIColor9, RSIText9, MFIColor9, MFIText9, AllG_Color9, AllG_Text9, MACD_Color9, MACDText9, FARMA_Color9, FARMAText9, ST_Color_219, ST_Text_219, ST_Color_149, ST_Text_149, ST_Color_109, ST_Text_109, RS_Text9, RS_Color9)
i == 12 => funcUpdateTableCells(i,w_r_t_Result10, t10, ts10, ts10Chng, ts10p, VWAPColor10, VWAPText10, trend10, BuySell10, ADXColor10, ADXText10, RSIColor10, RSIText10, MFIColor10, MFIText10, AllG_Color10, AllG_Text10, MACD_Color10, MACDText10, FARMA_Color10, FARMAText10, ST_Color_2110, ST_Text_2110, ST_Color_1410, ST_Text_1410, ST_Color_1010, ST_Text_1010, RS_Text10, RS_Color10)
i == 13 => funcUpdateTableCells(i,w_r_t_Result11, t11, ts11, ts11Chng, ts11p, VWAPColor11, VWAPText11, trend11, BuySell11, ADXColor11, ADXText11, RSIColor11, RSIText11, MFIColor11, MFIText11, AllG_Color11, AllG_Text11, MACD_Color11, MACDText11, FARMA_Color11, FARMAText11, ST_Color_2111, ST_Text_2111, ST_Color_1411, ST_Text_1411, ST_Color_1011, ST_Text_1011, RS_Text11, RS_Color11)
|
FRAMA and Candlestick Patterns [CSM] | https://www.tradingview.com/script/2sqUa8Z3-FRAMA-and-Candlestick-Patterns-CSM/ | chhagansinghmeena | https://www.tradingview.com/u/chhagansinghmeena/ | 151 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © chhagansinghmeena
//@version=5
indicator('FRAMA and Candlestick Patterns [CSM]', shorttitle='CSM FRAMA', overlay=true)
import chhagansinghmeena/BankNifty_CSM/2 as CM
// Input parameters
src = input.source(title = "FRAMA Source", defval = close)
length = input.int(title='Length', defval=20, minval=1, maxval=200)
fracDim = input.float(title='Fractal Dimension', defval=1.0, minval=0.1, maxval=2.0)
engF = input.bool(title = "Add Engulfing Candle Filter", defval = false)
// Calculate the FRAMA
framaCalculate(src, length, mult) =>
// Define the FRAMA function using a loop
alpha = 2 / (length + 1)
sum_wt = 0.0
sum_wt_src = 0.0
for i = 0 to length - 1 by 1
weight = math.exp(math.log(mult) * i * i / (length * length))
sum_wt += weight
sum_wt_src += weight * src[length - 1 - i]
sum_wt_src
frama_value = sum_wt_src / sum_wt
frama_value
frama = framaCalculate(src, length, fracDim)
get_EngulfimgBullish_Detection()=>
isEngulf = open[1] > close[1] ? close > open ? low >=low[1] ? open <= close[1] ? close - open > open[1] - close[1] ? true : false : false : false : false : false
get_EngulfimgBearish_Detection()=>
isEngulf = open[1] < close[1] ? close < open ? high <=high[1] ? open >= close[1] ? open - close > close[1] - open[1] ? true : false : false : false : false : false
bullishCandle = get_EngulfimgBullish_Detection()
bearishCandle = get_EngulfimgBearish_Detection()
// Detect bullish and bearish engulfing patterns
bullishEngulfing = bullishCandle or CM.candlepatternbullish()
bearishEngulfing = bearishCandle or CM.candlepatternbearish()
// Plot the FRAMA and RSI
plot(frama, color=color.new(color.orange, 0), linewidth=2)
buyFarma = frama < close
sellFarma = frama > close
//buy and sell signals based and candlestick patterns
if engF
buyFarma := buyFarma and bullishEngulfing
sellFarma := sellFarma and bearishEngulfing
Signal = 0
Signal := buyFarma ? 1 : sellFarma ? -1 : nz(Signal[1])
isDifferentSignalType = ta.change(Signal)
buySignal = buyFarma and isDifferentSignalType
sellSignal = sellFarma and isDifferentSignalType
plotshape(buySignal, title='Buy', style=shape.triangleup, location=location.belowbar, color=color.new(color.green, 0), size=size.small)
plotshape(sellSignal, title='Sell', style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.small)
|
Endpointed SSA of Price [Loxx] | https://www.tradingview.com/script/VPAKmSkt-Endpointed-SSA-of-Price-Loxx/ | loxx | https://www.tradingview.com/u/loxx/ | 432 | study | 5 | MPL-2.0 | // 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("Endpointed SSA of Price [Loxx]", overlay = true)
color greencolor = #2DD204
color redcolor = #D2042D
int Maxncomp = 25
int MaxLag = 200
int MaxArrayLength = 1000
// Calculation of the function Sn, needed to calculate the eigenvalues
// Negative determinants are counted there
gaussSn(matrix<float> A, float l, int n)=>
array<float> w = array.new<float>(n, 0)
matrix<float> B = matrix.copy(A)
int count = 0
int cp = 0
float c = 0.
float s1 = 0.
float s2 = 0.
for i = 0 to n - 1
matrix.set(B, i, i, matrix.get(B, i, i) - l)
for k = 0 to n - 2
for i = k + 1 to n - 1
if matrix.get(B, k, k) == 0
for i1 = 0 to n - 1
array.set(w, i1, matrix.get(B, i1, k))
matrix.set(B, i1, k, matrix.get(B, i1, k + 1))
matrix.set(B, i1, k + 1, array.get(w, i1))
cp := cp + 1
c := matrix.get(B, i, k) / matrix.get(B, k, k)
for j = 0 to n - 1
matrix.set(B, i, j, matrix.get(B, i, j) - matrix.get(B, k, j) * c)
count := 0
s1 := 1
for i = 0 to n - 1
s2 := matrix.get(B, i, i)
if s2 < 0
count := count + 1
count
// Calculation of eigenvalues by the bisection method}
// The good thing is that as many eigenvalues are needed, so many will count,
// saves a lot of resources
gaussbisectionl(matrix<float> A, int k, int n)=>
float e1 = 0.
float maxnorm = 0.
float cn = 0.
float a1 = 0.
float b1 = 0.
float c = 0.
for i = 0 to n - 1
cn := 0
for j = 0 to n - 1
cn := cn + matrix.get(A, i, i)
if maxnorm < cn
maxnorm := cn
a1 := 0
b1 := 10 * maxnorm
e1 := 1.0 * maxnorm / 10000000
while math.abs(b1 - a1) > e1
c := 1.0 * (a1 + b1) / 2
if gaussSn(A, c, n) < k
a1 := c
else
b1 := c
float out = (a1 + b1) / 2.0
out
// Calculates eigenvectors for already computed eigenvalues
svector(matrix<float> A, float l, int n, array<float> V)=>
int cp = 0
matrix<float> B = matrix.copy(A)
float c = 0
array<float> w = array.new<float>(n, 0)
for i = 0 to n - 1
matrix.set(B, i, i, matrix.get(B, i, i) - l)
for k = 0 to n - 2
for i = k + 1 to n - 1
if matrix.get(B, k, k) == 0
for i1 = 0 to n - 1
array.set(w, i1, matrix.get(B, i1, k))
matrix.set(B, i1, k, matrix.get(B, i1, k + 1))
matrix.set(B, i1, k + 1, array.get(w, i1))
cp += 1
c := 1.0 * matrix.get(B, i, k) / matrix.get(B, k, k)
for j = 0 to n - 1
matrix.set(B, i, j, matrix.get(B, i, j) - matrix.get(B, k, j) * c)
array.set(V, n - 1, 1)
c := 1
for i = n - 2 to 0
array.set(V, i, 0)
for j = i to n - 1
array.set(V, i, array.get(V, i) - matrix.get(B, i, j) * array.get(V, j))
array.set(V, i, array.get(V, i) / matrix.get(B, i, i))
c += math.pow(array.get(V, i), 2)
for i = 0 to n - 1
array.set(V, i, array.get(V, i) / math.sqrt(c))
// Fast Singular SSA - "Caterpillar" method
// X-vector of the original series
// n-length
// l-lag length
// s-number of eigencomponents
// (there the original series is divided into components, and then restored, here you set how many components you need)
// Y - the restored row (smoothed by the caterpillar)
fastsingular(array<float> X, int n1, int l1, int s1)=>
int n = math.min(MaxArrayLength, n1)
int l = math.min(MaxLag, l1)
int s = math.min(Maxncomp, s1)
matrix<float> A = matrix.new<float>(l, l, 0.)
matrix<float> B = matrix.new<float>(n, l, 0.)
matrix<float> Bn = matrix.new<float>(l, n, 0.)
matrix<float> V = matrix.new<float>(l, n, 0.)
matrix<float> Yn = matrix.new<float>(l, n, 0.)
var array<float> vtarr = array.new<float>(l, 0.)
array<float> ls = array.new<float>(MaxLag, 0)
array<float> Vtemp = array.new<float>(MaxLag, 0)
array<float> Y = array.new<float>(n, 0)
int k = n - l + 1
// We form matrix A in the method that I downloaded from the site of the creators of this matrix S
for i = 0 to l - 1
for j = 0 to l - 1
matrix.set(A, i, j, 0)
for m = 0 to k - 1
matrix.set(A, i, j, matrix.get(A, i, j) + array.get(X, i + m) * array.get(X, m + j))
matrix.set(B, m, j, array.get(X, m + j))
//Find the eigenvalues and vectors of the matrix A
for i = 0 to s - 1
array.set(ls, i, gaussbisectionl(A, l - i, l))
svector(A, array.get(ls, i), l, Vtemp)
for j = 0 to l - 1
matrix.set(V, i, j, array.get(Vtemp, j))
// The restored matrix is formed
for i1 = 0 to s - 1
for i = 0 to k - 1
matrix.set(Yn, i1, i, 0)
for j = 0 to l - 1
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(B, i, j) * matrix.get(V, i1, j))
for i = 0 to l - 1
for j = 0 to k - 1
matrix.set(Bn, i, j, matrix.get(V, i1, i) * matrix.get(Yn, i1, j))
//Diagonal averaging (series recovery)
int kb = k
int lb = l
for i = 0 to n - 1
matrix.set(Yn, i1, i, 0)
if i < lb - 1
for j = 0 to i
if l <= k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, j, i - j))
if l > k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, i - j, j))
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) / (1.0 * (i + 1)))
if (lb - 1 <= i) and (i < kb - 1)
for j = 0 to lb - 1
if l <= k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, j, i - j))
if l > k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, i - j, j))
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) / (1.0 * lb))
if kb - 1 <= i
for j = i - kb + 1 to n - kb
if l <= k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, j, i - j))
if l > k
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) + matrix.get(Bn, i - j, j))
matrix.set(Yn, i1, i, matrix.get(Yn, i1, i) / (1.0 * (n - i)))
// Here, if not summarized, then there will be separate decomposition components
// process by own functions
for i = 0 to n - 1
array.set(Y, i, 0)
for i1 = 0 to s - 1
array.set(Y, i, array.get(Y, i) + matrix.get(Yn, i1, i))
Y
float src = input.source(close, "Source", group = "Basic Settings")
int lag = input.int(10, "Lag", group = "Basic Settings")
int ncomp = input.int(2, "Number of Computations", group = "Basic Settings")
int ssapernorm = input.int(30, "SSA Period Normalization", group = "Basic Settings")
int numbars = input.int(330, "Number of Bars", group = "Basic Settings")
int backbars = input.int(400, "Number of Bars to Render", group = "Basic Settings", tooltip ="How many bars to plot.The higher the number the slower the computation.")
bool colorbars = input.bool(true, "Color bars?", group = "UI Options")
bool showSigs = input.bool(false, "Show signals?", group = "UI Options")
float out = 0.
float sig = 0.
float[] srcVal = array.new_float(numbars + 1, 0)
if last_bar_index - bar_index < backbars
for i = 0 to numbars - 1
array.set(srcVal, i, nz(src[i]))
float[] pv = fastsingular(srcVal, numbars, lag, ncomp)
out := array.get(pv, 0)
sig := out[1]
color colorout = out > sig ? greencolor : redcolor
bool goLong = ta.crossover(out, sig)
bool goShort = ta.crossunder(out, sig)
plot(last_bar_index - bar_index < backbars ? out : na, "Endpointed SSA of Price", color = colorout, linewidth = 2)
barcolor(last_bar_index - bar_index < backbars and colorbars ? colorout : na)
plotshape(showSigs and goLong, title = "Long", color = color.yellow, textcolor = color.yellow, text = "L", style = shape.triangleup, location = location.belowbar, size = size.auto)
plotshape(showSigs and goShort, title = "Short", color = color.fuchsia, textcolor = color.fuchsia, text = "S", style = shape.triangledown, location = location.abovebar, size = size.auto)
alertcondition(goLong, title = "Long", message = "Endpointed SSA of Price [Loxx]: Long\nSymbol: {{ticker}}\nPrice: {{close}}")
alertcondition(goShort, title = "Short", message = "Endpointed SSA of Price [Loxx]: Short\nSymbol: {{ticker}}\nPrice: {{close}}") |
Divergences in 52 Week Moving Averages, Adjusted and Smoothed | https://www.tradingview.com/script/tDteM2Iq-Divergences-in-52-Week-Moving-Averages-Adjusted-and-Smoothed/ | blueberryjones | https://www.tradingview.com/u/blueberryjones/ | 49 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © blueberryjones
//@version=5
indicator("Divergences in 52 Week Moving Averages, Adjusted and Smoothed", timeframe='D', overlay=true)
//Allow user to adjust EMA, 3 is standard.
emaLength = input.int(3, title="EMA Length")
//Allow user to adjust for sensitivity settings.
standardSignals = input.bool(true, title="Show Standard Signals")
sensitiveSignals = input.bool(true, title="Show Sensitive Signals")
highlysensitiveSignals = input.bool(true, title="Show Highly Sensitive Signals")
//Pull NAHF for 52-Week High Values, then apply EMA for smoothing.
hi_index = request.security("NAHF", "D", close)
hi_index_ema = ta.ema(hi_index,emaLength)
//Pull NALF for 52-Week Low Values, then apply EMA for smoothing.
lo_index = request.security("NALF", "D", close)
lo_index_ema = ta.ema(lo_index,emaLength)
//The logic below caps the areas for signals.
//Greater than 4.5 is considered to be a standard signal, few false positives appear here.
//Between 3.5 and 4.5 is considered to be sensitive.
//Between 2.5 and 3.5 is considered to be highly sensitive.
//Readings under 2.5 are excluded due to the high number of false positive and 'next day' moves that appear, feel free to adjust but it does not fit the intended style of the signal.
highly_sensitive_short_criteria = hi_index_ema >= 2.5 and hi_index_ema < 3.5
sensitive_short_criteria = hi_index_ema >= 3.5 and hi_index_ema < 4.5
standard_short_criteria = hi_index_ema >= 4.5
highly_sensitive_long_criteria = lo_index_ema >= 2.5 and lo_index_ema < 3.5
sensitive_long_criteria = lo_index_ema >= 3.5 and lo_index_ema < 4.5
standard_long_criteria = lo_index_ema >= 4.5
// Logic is applied here for a boolean (true/false) statement if the criteria has been met to signal a move.
highly_sensitive_short_signal = if highly_sensitive_short_criteria and highlysensitiveSignals
true
else
false
sensitive_short_signal = if sensitive_short_criteria and sensitiveSignals
true
else
false
standard_short_signal = if standard_short_criteria and standardSignals
true
else
false
highly_sensitive_long_signal = if highly_sensitive_long_criteria and highlysensitiveSignals
true
else
false
sensitive_long_signal = if sensitive_long_criteria and sensitiveSignals
true
else
false
standard_long_signal = if standard_long_criteria and standardSignals
true
else
false
// Unicode Characters (Emoji's) are plotted when crtiera has triggers, these emoji's are plotted corresponding to the Sensitivity Level that has been checked.
plotchar(highly_sensitive_short_signal, "Short", "❗️", location=location.abovebar, size = size.auto)
plotchar(sensitive_short_signal, "Short", "🆘", location=location.abovebar, size = size.auto)
plotchar(standard_short_signal, "Short", "🔻", location=location.abovebar, size = size.auto)
plotchar(highly_sensitive_long_signal, "Long", "❕", location=location.belowbar, size = size.auto)
plotchar(sensitive_long_signal, "Long", "🆙", location=location.belowbar, size = size.auto)
plotchar(standard_long_signal, "Long", "🔺", location=location.belowbar, size = size.auto) |
Sebastine Trend Catcher | https://www.tradingview.com/script/ipM8iQXh-Sebastine-Trend-Catcher/ | sebastinecc | https://www.tradingview.com/u/sebastinecc/ | 122 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © sebastinecc
//@version=5
indicator("Sebastine Trend Catcher")
len=input(5)
o=ta.ema(open,len)
c=ta.ema(close,len)
h=ta.ema(high,len)
l=ta.ema(low,len)
haclose = (o+h+l+c)/4
haopen = o // initialize haopen variable
haopen := na(haopen[1]) ? (o + c)/2 : (haopen[1] + haclose[1]) / 2
hahigh = math.max (h, math.max(haopen,haclose))
halow = math.min (l, math.min(haopen,haclose))
len2=input(5)
o2=ta.ema(haopen, len2)
c2=ta.ema(haclose, len2)
h2=ta.ema(hahigh, len2)
l2=ta.ema(halow, len2)
// calculate Sancho indicator
sebastine = ((c2 / o2) - 1) * 100
// plot the Sebastine, signal, upper and lower bands
color_sebastine = sebastine >= 0 ? color.green : color.red
plot(sebastine, color=color_sebastine, linewidth=2, title="sebastine",style=plot.style_stepline)
hline(0, title="Zero Line", color=color.white, linestyle=hline.style_dashed, linewidth=2) |
200 Week Moving Average Heatmap | https://www.tradingview.com/script/SzcosnpJ-200-Week-Moving-Average-Heatmap/ | VanHe1sing | https://www.tradingview.com/u/VanHe1sing/ | 85 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © VanHelsing666
//@version=5
indicator("200 Week Moving Average Heatmap", overlay = true)
sma = ta.sma(close, 1400) //200 Week Moving Average
sma_4w = sma[4*7] // 4 week ago Moving Average
delta_perc = (((sma-sma_4w) /sma_4w) * 100 ) // delta % increase of the 200 week moving average
rescale(value, fromMin, fromMax, toMin, toMax) =>
(value - fromMin) / (fromMax - fromMin) * (toMax - toMin) + toMin
len = 2000
normalize(x) =>
norm = 0.0
norm := (x - ta.lowest(x,len)) / (ta.highest(x,len) - ta.lowest(x,len))
2 * norm - 1
delta = rescale(normalize(delta_perc), -1, -0.17, 0, 16)
plot(sma, color = color.rgb(110, 39, 176), linewidth = 2)
color = delta >= 0 and delta < 2 ? color.from_gradient(delta , 0, 2, color.rgb(121, 46, 171), color.rgb(46, 54, 171))
: delta >= 2 and delta < 4 ? color.from_gradient(delta , 2, 4, color.rgb(46, 65, 171), color.rgb(46, 65, 171))
: delta >= 4 and delta < 6 ? color.from_gradient(delta , 4, 6, color.rgb(53, 70, 170), color.rgb(66, 121, 198))
: delta >= 6 and delta < 8 ? color.from_gradient(delta , 6, 8, color.rgb(63, 121, 201), color.rgb(59, 182, 143))
: delta >= 8 and delta < 10 ? color.from_gradient(delta , 8, 10, color.rgb(58, 184, 144), color.rgb(103, 190, 62))
: delta >= 10 and delta < 12 ? color.from_gradient(delta , 10, 12, color.rgb(98, 189, 57), color.rgb(181, 194, 62))
: delta >= 12 and delta < 14 ? color.from_gradient(delta , 12, 14, color.rgb(159, 171, 56), color.rgb(171, 115, 55))
: delta >= 14 and delta < 16 ? color.from_gradient(delta , 14, 16, color.rgb(177, 117, 54), color.rgb(212, 66, 66))
: na
plotchar(close, "Colored Values ●", char = "●", color = color, location = location.absolute, size = size.small)
plot(hl2, "Price", color = color.gray)
array_color = array.new<color>()
array.push(array_color, color.rgb(252, 69, 69))
array.push(array_color, color.rgb(255, 157, 52))
array.push(array_color, color.rgb(161, 172, 61))
array.push(array_color, color.rgb(98, 176, 61))
array.push(array_color, color.rgb(50, 158, 124))
array.push(array_color, color.rgb(43, 104, 189))
array.push(array_color, color.rgb(46, 54, 171))
array.push(array_color, color.rgb(84, 46, 171))
//Value
valuation = (rescale(delta, 0, 16, -1, 1) > -0.5 ? rescale(delta, 0, 16, -1, 1) + 0.5 : rescale(delta, 0, 16, -1, 1))*-1
valuation_ = valuation < -1 ? -1 : valuation
plot(valuation_, "Valuation Scale", color = color.from_gradient(valuation_, -1, 1, color.rgb(237, 22, 22), color.blue), display = display.none)
plot(delta_perc, "Delta % changing of 200 Week MA", color = color, display = display.none)
// Table
table = table.new(position.middle_right, 10, 25, bgcolor = color.rgb(54, 58, 69, 100))
for i = 0 to array.size(array_color)-1
table.cell(table, 1, i,bgcolor = array.get(array_color, i))
for s = 0 to array.size(array_color)-1
table.cell(table, 0, s, text = str.tostring(s == 0 ? 16 : s == 1 ? 14 : s == 2 ? 12 : s == 3 ? 10 : s == 4 ? 8 : s == 5 ? 6 : s == 6 ? 4 : s == 7 ? 2 : 0), text_color= color.white, text_size = size.large)
table.cell(table, 0, 9)
table.cell(table, 0, 10, text = "Value:", text_color = color, text_size = size.large)
table.cell(table, 1, 10, text = str.tostring(math.round(valuation_, 2)), text_color = color, text_size = size.large)
//Alert
alert("200 Week Moving Average Heatmap " + str.tostring(math.round(valuation_, 2)), alert.freq_once_per_bar) |
Simple Moving Average Slope [AstrideUnicorn] | https://www.tradingview.com/script/CMitPGXF-Simple-Moving-Average-Slope-AstrideUnicorn/ | AstrideUnicorn | https://www.tradingview.com/u/AstrideUnicorn/ | 281 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © AstrideUnicorn
//@version=5
indicator("Simple Moving Average Slope [AstrideUnicorn]", shorttitle = "SMAS [AstrideUnicorn]", overlay = false)
// Inputs
window = input(20, "Window")
threshold = input(0.6, "Threshold")
// Calculate the Simple Moving Average slope
sma_slope = ta.sma(close,window) - ta.sma(close[1], window)
// Normalize the Simple Moving Average slope by dividing it by the long-term strandard deviation of the slope
normalized_sma_slope = sma_slope / ta.stdev(sma_slope, window*10)
// Define the conditional color variable
color_trend = normalized_sma_slope > threshold ? color.green : normalized_sma_slope < -threshold ? color.red : color.blue
// Plot the zero level
plot(0)
// Plot the normalized Simple Moving Average slope curve
ns = plot(normalized_sma_slope, color = color_trend)
// Plot the threshold levels
t_upper = plot(threshold)
t_lower = plot(-threshold)
// Fill the area under the the indicator curve with the conditional color
fill(ns,t_upper, normalized_sma_slope > threshold ? color_trend : na)
fill(ns,t_lower, normalized_sma_slope < -threshold ? color_trend : na) |
Bearish Flag Patterns [theEccentricTrader] | https://www.tradingview.com/script/PcwsfiUX-Bearish-Flag-Patterns-theEccentricTrader/ | theEccentricTrader | https://www.tradingview.com/u/theEccentricTrader/ | 34 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © theEccentricTrader
//@version=5
indicator('Bearish Flag Patterns [theEccentricTrader]', overlay = true, max_lines_count = 500, max_labels_count = 350)
//////////// shsl ////////////
shPrice = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? high :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? high[1] : na
shPriceBarIndex = close[1] >= open[1] and close < open and high >= high[1] and barstate.isconfirmed ? bar_index :
close[1] >= open[1] and close < open and high <= high[1] and barstate.isconfirmed ? bar_index - 1 : na
peak = ta.valuewhen(shPrice, shPrice, 0)
peakBarIndex = ta.valuewhen(shPrice, shPriceBarIndex, 0)
shPriceOne = ta.valuewhen(shPrice, shPrice, 1)
shPriceBarIndexOne = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 1)
shPriceTwo = ta.valuewhen(shPrice, shPrice, 2)
shPriceBarIndexTwo = ta.valuewhen(shPriceBarIndex, shPriceBarIndex, 2)
slPrice = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? low :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? low[1] : na
slPriceBarIndex = close[1] < open[1] and close >= open and low <= low[1] and barstate.isconfirmed ? bar_index :
close[1] < open[1] and close >= open and low >= low[1] and barstate.isconfirmed ? bar_index - 1 : na
trough = ta.valuewhen(slPrice, slPrice, 0)
troughBarIndex = ta.valuewhen(slPrice, slPriceBarIndex, 0)
slPriceOne = ta.valuewhen(slPrice, slPrice, 1)
slPriceBarIndexOne = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 1)
slPriceTwo = ta.valuewhen(slPrice, slPrice, 2)
slPriceBarIndexTwo = ta.valuewhen(slPriceBarIndex, slPriceBarIndex, 2)
returnLineUptrend = ta.valuewhen(shPrice, shPrice, 0) > ta.valuewhen(shPrice, shPrice, 1)
uptrend = ta.valuewhen(slPrice, slPrice, 0) > ta.valuewhen(slPrice, slPrice, 1)
downtrend = ta.valuewhen(shPrice, shPrice, 0) < ta.valuewhen(shPrice, shPrice, 1)
returnLineDowntrend = ta.valuewhen(slPrice, slPrice, 0) < ta.valuewhen(slPrice, slPrice, 1)
addUnbrokenTrough = input(defval = false, title = 'Unbroken Troughs', group = 'Logic')
unbrokenTrough = addUnbrokenTrough ? low > trough : true
slRangeRatio = (peak - trough) / (peak - trough[1]) * 100
shRangeRatio = (peak - trough) / (peak[1] - trough) * 100
slRangeRatioZero = ta.valuewhen(slPrice, slRangeRatio, 0)
slRangeRatioOne = ta.valuewhen(slPrice, slRangeRatio, 1)
shRangeRatioZero = ta.valuewhen(shPrice, shRangeRatio, 0)
shRangeRatioOne = ta.valuewhen(shPrice, shRangeRatio, 1)
beRangeRatio = (peak - slPriceOne) / (shPriceTwo - slPriceOne) * 100
abRatio = input(defval = 100, title = 'AB Minimum Ratio', group = 'Range Ratios')
bcRatio = input(defval = 30, title = 'BC Maximum Ratio', group = 'Range Ratios')
beRatio = input(defval = 40, title = 'BE Maximum Ratio', group = 'Range Ratios')
bearishFlag = shPrice and returnLineUptrend and uptrend and downtrend[1] and unbrokenTrough
and slRangeRatioOne >= abRatio
and shRangeRatioOne <= bcRatio
and beRangeRatio <= beRatio
//////////// lines ////////////
poleColor = input(defval = color.blue, title = 'Pole Color', group = 'Pattern Lines')
flagColor = input(defval = color.red, title = 'Flag Color', group = 'Pattern Lines')
selectFlagExtend = input.string(title = 'Extend Current Flag Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Pattern Lines")
extendFlagLines = selectFlagExtend == 'None' ? extend.none : selectFlagExtend == 'Right' ? extend.right :
selectFlagExtend == 'Left' ? extend.left : selectFlagExtend == 'Both' ? extend.both : na
showLabels = input(defval = true, title = 'Show Labels', group = 'Labels')
labelColor = input(defval = color.blue, title = 'Label Color', group = 'Labels')
showProjections = input(defval = true, title = 'Show Projections', group = 'Projection Lines')
selectProjectionExtend = input.string(title = 'Extend Current Projection Lines', defval = 'None', options = ['None', 'Right', 'Left', 'Both'], group = "Projection Lines")
extendProjectionLines = selectProjectionExtend == 'None' ? extend.none : selectProjectionExtend == 'Right' ? extend.right :
selectProjectionExtend == 'Left' ? extend.left : selectProjectionExtend == 'Both' ? extend.both : na
var currentResistanceLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentSupportLine = line.new(na, na, na, na, extend = extendFlagLines, color = flagColor, width = 2)
var currentPatternPeak = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternTrough = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
var currentPatternUpperProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.green, style = line.style_dashed)
var currentPatternLowerProjection = line.new(na, na, na, na, extend = extendProjectionLines, color = color.red, style = line.style_dashed)
if bearishFlag
lineOne = line.new(shPriceBarIndexTwo, shPriceTwo, slPriceBarIndexOne, slPriceOne, color = poleColor, width = 2)
lineTwo = line.new(slPriceBarIndexOne, slPriceOne, troughBarIndex, trough, color = flagColor, width = 2)
lineThree = line.new(shPriceBarIndexOne, shPriceOne, shPriceBarIndex, shPrice, color = flagColor, width = 2)
patternPeak = line.new(showProjections ? peakBarIndex : na, showProjections ? peak : na, showProjections ? bar_index + 1 : na,
showProjections ? peak : na, color = color.green, style = line.style_dashed)
patternTrough = line.new(showProjections ? troughBarIndex : na, showProjections ? trough : na, showProjections ? bar_index + 1 : na,
showProjections ? trough : na, color = color.red, style = line.style_dashed)
patternUpperProjection = line.new(showProjections ? shPriceBarIndexTwo : na, showProjections ? shPriceTwo : na, showProjections ? bar_index + 1 : na,
showProjections ? shPriceTwo : na, color = color.green, style = line.style_dashed)
patternLowerProjection = line.new(showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na, showProjections ? bar_index + 1 : na,
showProjections ? trough - (shPriceTwo - slPriceOne) : na, color = color.red, style = line.style_dashed)
line.set_xy1(currentResistanceLine, shPriceBarIndexOne, shPriceOne)
line.set_xy2(currentResistanceLine, peakBarIndex, peak)
line.set_xy1(currentSupportLine, slPriceBarIndexOne, slPriceOne)
line.set_xy2(currentSupportLine, troughBarIndex, trough)
line.set_xy1(currentPatternPeak, showProjections ? peakBarIndex : na, showProjections ? peak : na)
line.set_xy2(currentPatternPeak, showProjections ? bar_index + 1: na, showProjections ? peak : na)
line.set_xy1(currentPatternTrough, showProjections ? troughBarIndex : na, showProjections ? trough : na)
line.set_xy2(currentPatternTrough, showProjections ? bar_index + 1: na, showProjections ? trough : na)
line.set_xy1(currentPatternUpperProjection, showProjections ? shPriceBarIndexTwo : na, showProjections ? shPriceTwo : na)
line.set_xy2(currentPatternUpperProjection, showProjections ? bar_index + 1: na, showProjections ? shPriceTwo : na)
line.set_xy1(currentPatternLowerProjection, showProjections ? troughBarIndex : na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
line.set_xy2(currentPatternLowerProjection, showProjections ? bar_index + 1: na, showProjections ? trough - (shPriceTwo - slPriceOne) : na)
labelOne = label.new(showLabels ? shPriceBarIndexTwo : na, showLabels ? shPriceTwo : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'A', textcolor = labelColor)
labelTwo = label.new(showLabels ? slPriceBarIndexOne : na, showLabels ? slPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'B (' + str.tostring(math.round(slRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelThree = label.new(showLabels ? shPriceBarIndexOne : na, showLabels ? shPriceOne : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'C (' + str.tostring(math.round(shRangeRatioOne, 2)) + ')', textcolor = labelColor)
labelFour = label.new(showLabels ? troughBarIndex : na, showLabels ? trough : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_up,
text = 'D (' + str.tostring(math.round(slRangeRatioZero, 2)) + ')', textcolor = labelColor)
labelFive = label.new(showLabels ? shPriceBarIndex : na, showLabels ? shPrice : na, color = color.rgb(54, 58, 69, 100), style = label.style_label_down,
text = 'E (' + str.tostring(math.round(beRangeRatio, 2)) + ')', textcolor = labelColor)
var myLineArray = array.new_line()
array.push(myLineArray, lineOne)
array.push(myLineArray, lineTwo)
array.push(myLineArray, lineThree)
array.push(myLineArray, patternPeak)
array.push(myLineArray, patternTrough)
array.push(myLineArray, patternUpperProjection)
array.push(myLineArray, patternLowerProjection)
if array.size(myLineArray) >= 500
firstLine = array.remove(myLineArray, 0)
line.delete(firstLine)
var myLabelArray = array.new_label()
array.push(myLabelArray, labelOne)
array.push(myLabelArray, labelTwo)
array.push(myLabelArray, labelThree)
array.push(myLabelArray, labelFour)
array.push(myLabelArray, labelFive)
if array.size(myLabelArray) >= 350
firstLabel = array.remove(myLabelArray, 0)
label.delete(firstLabel)
alert('Bearish Flag')
|
Trading Zones based on RS / Volume / Pullback | https://www.tradingview.com/script/iddLXlFM-Trading-Zones-based-on-RS-Volume-Pullback/ | InvestIn10 | https://www.tradingview.com/u/InvestIn10/ | 99 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © InvestIn10
//@version=5
indicator("Trading Zones based on RS / Volume / Pullback", shorttitle = "Trading Zones from: RS / Volume / Pullback", overlay = true)
// Default color constants using tranparency of 25.
GREY_COLOR = #7d7e7f2f
GREEN_COLOR = #30663177
ORANGE_COLOR = color.rgb(255, 128, 0, 80)
RED_COLOR = #e30f0f52
NO_COLOR = color(na)
var SessionColor = NO_COLOR
// Relative Symbol
Rel_sym = input.symbol("NSE:NIFTY", "Relative Symbol")
// Flags
var LongActive = false
var EntryZone = false
var WarningZone = false
var ProbableTopZone = false
Relative = request.security(Rel_sym, timeframe.period, close)
Sym = request.security(syminfo.tickerid, timeframe.period, close)
HYr_period = 125
Qtr_period = 63
Month_period = 21
Week_period = 5
// Volume Avg
var float Volume_Avg_Qtr = 0
var float Volume_Avg_Month = 0
var float Volume_Avg_Week = 0
Volume_Avg_Week := 0
for i = 0 to Week_period by 1
Volume_Avg_Week := Volume_Avg_Week + volume[i]
Volume_Avg_Week := Volume_Avg_Week / Week_period
Volume_Avg_Month := 0
for i = 0 to Month_period by 1
Volume_Avg_Month := Volume_Avg_Month + volume[i]
Volume_Avg_Month := Volume_Avg_Month / Month_period
Volume_Avg_Qtr := 0
for i = 0 to Qtr_period by 1
Volume_Avg_Qtr := Volume_Avg_Qtr + volume[i]
Volume_Avg_Qtr := Volume_Avg_Qtr / Qtr_period
// -- Retracements
HYr_high = ta.highest(Sym,HYr_period)
HYr_low = ta.lowest(Sym,HYr_period)
HYr_Swing = (HYr_high - HYr_low)/HYr_low
HYr_Retrace = (HYr_high - Sym)/(HYr_high - HYr_low)
Qtr_high = ta.highest(Sym,Qtr_period)
Qtr_low = ta.lowest(Sym,Qtr_period)
Qtr_Swing = (Qtr_high - Qtr_low)/Qtr_low
Qtr_Retrace = (Qtr_high - Sym)/(Qtr_high - Qtr_low)
Month_high = ta.highest(Sym,Month_period)
Month_low = ta.lowest(Sym,Month_period)
Month_Swing = (Month_high - Month_low)/Month_low
Month_Retrace = (Month_high - Sym)/(Month_high - Month_low)
Combi_Retrace = HYr_Retrace+Qtr_Retrace+Month_Retrace
//-- RS
RS_HYr = (Sym / Sym[HYr_period]) / (Relative / Relative[HYr_period]) - 1
RS_Qtr = (Sym / Sym[Qtr_period]) / (Relative / Relative[Qtr_period]) - 1
RS_Month = (Sym / Sym[Month_period]) / (Relative / Relative[Month_period]) - 1
RS_ma = 5
RS_HYr_ma = ta.ema(RS_HYr,RS_ma)
RS_Qtr_ma = ta.ema(RS_Qtr,RS_ma)
RS_Month_ma = ta.ema(RS_Month,RS_ma)
//---------- Generate Signals: State Machine: for Different Zones
if LongActive == false and Combi_Retrace < 0.1 and RS_Qtr_ma > 0 and RS_HYr_ma[0] > RS_HYr_ma[5]
LongActive := true
if LongActive == true
// entry zone
if Combi_Retrace > 0.75 and RS_Qtr_ma > 0 and RS_Qtr_ma[0] > RS_Qtr_ma[5]
if Volume_Avg_Week < 0.9*Volume_Avg_Month or Volume_Avg_Month < 0.85*Volume_Avg_Qtr
EntryZone := true
else
EntryZone := false
else
EntryZone := false
// warning zone
if Combi_Retrace > 2.2 and RS_Qtr_ma < 0
WarningZone := true
EntryZone := false
if WarningZone == true and Combi_Retrace < 0.1 and RS_Qtr_ma > 0
WarningZone := false
// search probable tops
if WarningZone == true and Combi_Retrace < 1.0
ProbableTopZone := true
if ProbableTopZone == true
if Combi_Retrace < 1.2 and Combi_Retrace >= 0.1
ProbableTopZone := true
else if Combi_Retrace < 0.1 and RS_Qtr_ma > 0
ProbableTopZone := false
LongActive := true
else if Combi_Retrace > 1 or RS_Qtr_ma < 0
ProbableTopZone := false
LongActive := false
// ------------- END State Machine
if LongActive == true
SessionColor := GREY_COLOR
if EntryZone == true
SessionColor := GREEN_COLOR
if WarningZone == true
SessionColor := ORANGE_COLOR
if ProbableTopZone == true
SessionColor := RED_COLOR
else
SessionColor := NO_COLOR
// DEBUG Plots -- Dont delete -- will be needed for future debug
// hline(0,linewidth = 2)
// hline(1,linewidth = 1)
// hline(0.23, color = color.green)
// hline(0.50, color = color.red)
// plot(HYr_Retrace,color = color.lime)
// plot(Qtr_Retrace, color = color.rgb(230, 128, 11))
// plot(Month_Retrace, color = color.red)
// plot(Combi_Retrace, color =color.gray, linewidth = 2)
// hline(2)
// plot(2+RS_Qtr_ma, color = color.rgb(230, 128, 11),linewidth = 2)
// plot(2+RS_Month_ma, color = color.rgb(230, 33, 11, 3),linewidth = 2)
bgcolor(SessionColor)
//Table
var table Index_color = table.new(position.top_right,1,4,bgcolor = GREY_COLOR)
if barstate.islast
table.cell(Index_color, 0, 0, "LONG Zone",bgcolor = GREY_COLOR, text_color = color.white)
table.cell(Index_color, 0, 1, "ENTRY Zone",bgcolor = GREEN_COLOR, text_color = color.white)
table.cell(Index_color, 0, 2, "WARNING Zone",bgcolor = ORANGE_COLOR, text_color = color.white)
table.cell(Index_color, 0, 3, "EXIT Zone",bgcolor = RED_COLOR, text_color = color.white)
|
Price Level Stats (PLS) | https://www.tradingview.com/script/4pJi8NfK-Price-Level-Stats-PLS/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 37 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("Price Level Stats", "PLS", precision = 3, overlay = true)
import RicardoSantos/MathSpecialFunctionsGamma/1
// Types
type vec2
float x
float y
// Helper functions
gamma(float x) => MathSpecialFunctionsGamma.Gamma(x)
logReturn(float a, float b) => math.log(a / b)
percent(float a, float b) => (a - b) / b * 100
addLogReturn(float a, float b) => a * math.exp(b)
addPercentage(float a, float b) => a * (1 + b / 100)
subtractPercentage(float a, float b) => a * (1 - b / 100)
stepToInt(float stepSize) => int(stepSize * 100)
ema(float source = close, float length = 9)=>
alpha = 2 / (length + 1)
var float smoothed = na
smoothed := alpha * source + (1 - alpha) * nz(smoothed[1])
t_dist_pdf(float x, int v) =>
gamma((v + 1) / 2) / (math.sqrt(v * math.pi) * gamma(v / 2)) * math.pow(1 + x * x / v, -(v + 1) / 2)
rising_factorial(float c, int n) =>
float product = 1.0
if n > 0
for i = 0 to n - 1
product *= (c + i)
product
hypergeometric(float a, float b, float c, float z) =>
float sum = 0.0
for i = 0 to 2
sum += rising_factorial(a, i) * rising_factorial(b, i) * math.pow(z, i) / (rising_factorial(c, i) * rising_factorial(i, i))
sum
t_dist_cdf(float x, int v) =>
1/2.0 + x * gamma((v+1)/2.0) * (hypergeometric(1/2.0, (v+1)/2.0, 3.0/2, x*x/v) / (math.sqrt(v * math.pi)* gamma(v/2)))
// Price Movement Probability (T-Dist) function
priceMovementProbabilityTDist(float inputPrice, float mean, series int meanLength) =>
float p = (1 - 0.99) / 2
float lower = -100
float upper = 100
float mid = (lower + upper) / 2
while math.abs(t_dist_cdf(mid, meanLength - 1) - p) > 0.000001
if t_dist_cdf(mid, meanLength - 1) > p
upper := mid
else
lower := mid
mid := (lower + upper) / 2
float t_value = mid
if t_value < 0
t_value := -t_value
float squared_diff = math.pow(open-mean, 2)
float summed_squares = math.sum(squared_diff, meanLength)
float mean_squared_error = summed_squares / (meanLength-1)
float rmse = math.sqrt(mean_squared_error)
float root_standard_error = math.sqrt(1 + 1/meanLength + squared_diff/summed_squares)
float offset = t_value * rmse * root_standard_error
float zscore = (inputPrice-mean)/offset
float probability = t_dist_pdf(zscore, meanLength - 1)
probability
drawProbability(vec2 source, bool logReturns) =>
price = array.new<label>(1)
lines = array.new<line>(1)
if barstate.islast
array.push(price, label.new(bar_index + 2, source.x, text = str.tostring(math.round(source.y * (logReturns ? 1 : 100), 2))+"%", style=label.style_label_down, textcolor = source.x > open ? color.green : color.red, color=color.new(color.white, 100)))
array.push(lines, line.new(bar_index, source.x, bar_index + 1, source.x, color = source.x > open ? color.green : color.red))
if barstate.isconfirmed
for i = 0 to array.size(price) - 1
label.delete(array.get(price, i))
line.delete(array.get(lines, i))
source = input.source(open, "Source")
stepSize = stepToInt(input.float(0.2, "Step Size", 0.001, 100, 0.001))
steps = input.int(1, "Steps", 1, 100, 1)
meanLength = input.int(20, "Mean/Deviation Length", 5)
style = input.string("Bar Estimate", "Style", ["Bar Estimate", "Log Bar Estimate", "Student's T"])
useLogReturns = style == "Log Bar Estimate" ? true : false
var movement_size_green = array.new<float>(100)
var count_green = array.new<int>(100)
var movement_size_red = array.new<float>(100)
var count_red = array.new<int>(100)
change = useLogReturns ? math.round(logReturn(close, close[1]), 4) : math.round(percent(close, close[1]), 4)
float mean = ema(open, meanLength)
if close > open
if array.includes(movement_size_green, change)
index = array.indexof(movement_size_green, change)
array.set(count_green, index, array.get(count_green, index) + 1)
else
array.push(movement_size_green, change)
array.push(count_green, 1)
if close < open
if array.includes(movement_size_red, change)
index = array.indexof(movement_size_red, change)
array.set(count_red, index, array.get(count_red, index) + 1)
else
array.push(movement_size_red, change)
array.push(count_red, 1)
probability_green = array.new<float>(array.size(count_green))
probability_red = array.new<float>(array.size(count_red))
count_green_sum = array.sum(count_green)
count_red_sum = array.sum(count_red)
for i = 0 to array.size(count_green) - 1
probability = array.get(count_green, i) / count_green_sum * 100
array.set(probability_green, i, probability)
for i = 0 to array.size(count_red) - 1
probability = array.get(count_red, i) / count_red_sum * 100
array.set(probability_red, i, probability)
if style != "Student's T"
for i = stepSize to stepSize * steps by stepSize
inputPriceBullish = addPercentage(source, i/100.0)
inputPcireBearish = subtractPercentage(source, i/100.0)
arb_price_bullish = useLogReturns ? math.round(logReturn(inputPriceBullish, open), 4) : math.round(percent(inputPriceBullish, open), 4)
arb_price_bearish = useLogReturns ? math.round(logReturn(inputPcireBearish, open), 4) : math.round(percent(inputPcireBearish, open), 4)
green_index_up = array.indexof(movement_size_green, arb_price_bullish)
red_index_up = array.indexof(movement_size_red, arb_price_bearish)
green_index_down = array.indexof(movement_size_green, arb_price_bullish)
red_index_down = array.indexof(movement_size_red, arb_price_bearish)
probability_up = inputPriceBullish > 0 and green_index_up != -1 ? array.get(probability_green, green_index_up) : inputPriceBullish < 0 and red_index_up != -1 ? array.get(probability_red, red_index_up) : 0
probability_down = inputPcireBearish > 0 and green_index_down != -1 ? array.get(probability_green, green_index_down) : inputPcireBearish < 0 and red_index_down != -1 ? array.get(probability_red, red_index_down) : 0
drawProbability(vec2.new(inputPriceBullish, probability_up), useLogReturns)
drawProbability(vec2.new(inputPcireBearish, probability_down), useLogReturns)
else
for i = stepSize to stepSize * steps by stepSize
inputPriceBullish = addPercentage(source, i/100.0)
inputPcireBearish = subtractPercentage(source, i/100.0)
probability_up = priceMovementProbabilityTDist(inputPriceBullish, mean, meanLength)
probability_down = priceMovementProbabilityTDist(inputPcireBearish, mean, meanLength)
drawProbability(vec2.new(inputPriceBullish, probability_up), false)
drawProbability(vec2.new(inputPcireBearish, probability_down), false) |
Expected Volatility | https://www.tradingview.com/script/dsXscaGY-Expected-Volatility/ | ShadowOfCrimson | https://www.tradingview.com/u/ShadowOfCrimson/ | 35 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © ShadowOfCrimson
//Notes: request.security can only be called 40 times in one script, use it more sparingly to allow the script to draw
//more boxes back for backtesting... there should be a more effective way to do it.
//@version=5
indicator("Expected Volatility", overlay = true, max_bars_back = 500)
//This indicator shows expected move sizes when correlated with each volatility index.
//turn this variable on to test what market the chart thinks it is on.
troubleshooting = input(false, "Troubleshooting?")
box_transparency = input(80, "Transparency") //Allow user to change the transparency of the indicator
sess_Time = input("0930-1600", "Session Time") //Allow user to input custom session time
sess_TimeZone = input("GMT-4", "TimeZone") //Allow user to input custom timezone
close_day = close[1] //The previous day's closing price
// Market and Volatility Index pairs begin:
// ES & VIX
// Request the previous day's settlement on ES
ES = request.security( //function to request data from a different chart
"CME_MINI:ES1!", //the name of the security requested
"1D", //the timeframe of the request
close_day, //the time requested
gaps = barmerge.gaps_off, //merge strategy for requested data
lookahead = barmerge.lookahead_on //merge strategy for the requested data position
)
// plot an invisible ES chart to see the values in the data window during troubleshooting
plotES = plot(ES,"ES",color = color.new(color.white,100))
// Request the previous day's settlement on VIX
VIX = request.security(
"CBOE:VIX",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible VIX chart to see the values in the data window during troubleshooting
plotVIX = plot(VIX,"VIX",color = color.new(color.white,100))
// NQ & VOLQ
// Request the previous day's settlement on NQ
NQ = request.security(
"CME_MINI:NQ1!",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible NQ chart to see the values in the data window during troubleshooting
plotNQ = plot(NQ,"NQ",color = color.new(color.white,100))
// Request the previous day's settlement on VOLQ
VOLQ = request.security(
"NASDAQ:VOLQ",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible VOLQ chart to see the values in the data window during troubleshooting
plotVOLQ = plot(VOLQ,"VOLQ",color = color.new(color.white,100))
// CL & OVX
// Request the previous day's settlement on CL
CL = request.security(
"NYMEX:CL1!",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible CL chart to see the values in the data window during troubleshooting
plotCL = plot(CL,"CL",color = color.new(color.white,100))
// Request the previous day's settlement on OVX
OVX = request.security(
"CBOE:OVX",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible OVX chart to see the values in the data window during troubleshooting
plotOVX = plot(OVX,"OVX",color = color.new(color.white,100))
// RTY & RVX
// Request the previous day's settlement on RTY
RTY = request.security(
"CME_MINI:RTY1!",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible RTY chart to see the values in the data window during troubleshooting
plotRTY = plot(RTY,"RTY",color = color.new(color.white,100))
// Request the previous day's settlement on RVX
RVX = request.security(
"CBOE:RVX",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible RVX chart to see the values in the data window during troubleshooting
plotRVX = plot(RVX,"RVX",color = color.new(color.white,100))
// VIX & VVIX
// Request the previous day's settlement on VVIX
VVIX = request.security(
"CBOE:VVIX",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible VVIX chart to see the values in the data window during troubleshooting
plotVVIX = plot(VVIX,"VVIX",color = color.new(color.white,100))
// GC & GVZ
// Request the previous day's settlement on GC
GC = request.security(
"COMEX:GC1!",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible GC chart to see the values in the data window during troubleshooting
plotGC = plot(GC,"GC",color = color.new(color.white,100))
// Request the previous day's settlement on GVZ
GVZ = request.security(
"CBOE:GVZ",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible GVZ chart to see the values in the data window during troubleshooting
plotGVZ = plot(GVZ,"GVZ",color = color.new(color.white,100))
// SI & VXSLV
// Request the previous day's settlement on SI
SI = request.security(
"MCX:SILVER1!",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible SI chart to see the values in the data window during troubleshooting
plotSI = plot(SI,"SI",color = color.new(color.white,100))
// Request the previous day's settlement on VXSLV
VXSLV = request.security(
"CBOE:VXSLV",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible VXSLV chart to see the values in the data window during troubleshooting
plotVXSLV = plot(VXSLV,"VXSLV",color = color.new(color.white,100))
// YM & VXD
// Request the previous day's settlement on YM
YM = request.security( //function to request data from a different chart
"CBOT_MINI:YM1!", //the name of the security requested
"1D", //the timeframe of the request
close_day, //the time requested
gaps = barmerge.gaps_off, //merge strategy for requested data
lookahead = barmerge.lookahead_on //merge strategy for the requested data position
)
// plot an invisible ES chart to see the values in the data window during troubleshooting
plotYM = plot(YM,"YM",color = color.new(color.white,100))
// Request the previous day's settlement on VXD
VXD = request.security(
"CBOE:VXD",
"1D",
close_day,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)
// plot an invisible VIX chart to see the values in the data window during troubleshooting
plotVXD = plot(VXD,"VXD",color = color.new(color.white,100))
// Market and Volatility Index pairs end
// Useful function from tradingcode.net:
// IsSessionStart() returns 'true' when the current bar is the first one
// inside the specified session, adjusted to the given time zone (optional).
// Returns 'false' for other bars inside the session, bars outside the
// session, and when the time frame is 1 day or higher.
IsSessionStart(sessionTime, sessionTimeZone=syminfo.timezone) =>
inSess = not na(time(timeframe.period, sessionTime, sessionTimeZone))
inSess and not inSess[1]
//bgcolor(IsSessionStart("0930-1600", "GMT-4") ? color.new(color.blue, 80) : na)
// This function takes the input volatility index and calculates variables a and b
// a and b are used later to calculate zones based on standard deviations
GetVolatility(VolatilityIndex) =>
a = VolatilityIndex/16/100 //VIX_A
b = VolatilityIndex/math.sqrt(365)/100 //VIX_B
[a,b]
// This function does all the math to generate the zones when given variables
// a, b, and Index, where a and b are the results of GetVolatility(VolatilityIndex)
// and Index is the Index correlated to the VolatilityIndex of interest.
Zones(a,b,Index) =>
//Top Zone calculations:
Index_STD1UP = Index * a //STD. DEV. 1.0 FOR Index
Index_STD1DN = Index * b //STD. DEV. 1.0 FOR Index
Index_ZONE1UP_Res = Index_STD1UP + Index //Upper std. dev. 1.0
Index_ZONE1DN_Res = Index_STD1DN + Index //Lower std. dev. 1.0
Index_ZONE150UP_Res = Index_STD1UP * 1.5 + Index //1.5 STD. DEV. ZONE UPPER
Index_ZONE150DN_Res = Index_STD1DN * 1.5 + Index //1.5 STD. DEV. ZONE LOWER
Index_ZONE50UP_Res = Index_STD1UP * .5 + Index //.5 STD. DEV. ZONE UPPER
Index_ZONE50DN_Res = Index_STD1DN * .5 + Index //.5 STD. DEV. ZONE LOWER
Index_ZONE25UP_Res = Index_STD1UP * .25 + Index //.25 STD. DEV. ZONE UPPER
Index_ZONE25DN_Res = Index_STD1DN * .25 + Index //.25 STD. DEV. ZONE LOWER
//Bottom Zone calculations:
Index_ZONE1UP_Sup = Index - Index_STD1DN //SUBTRACT 1.0 STD. DEV. FROM PRICE
Index_ZONE1DN_Sup = Index - Index_STD1UP //SUBTRACT 1.0 STD. DEV. FROM PRICE
Index_ZONE150UP_Sup = Index - (Index_ZONE150DN_Res-Index)
Index_ZONE150DN_Sup = Index - (Index_ZONE150UP_Res-Index)
Index_ZONE50UP_Sup = Index - (Index_ZONE50DN_Res-Index)
Index_ZONE50DN_Sup = Index - (Index_ZONE50UP_Res-Index)
Index_ZONE25UP_Sup = Index - (Index_ZONE25DN_Res-Index)
Index_ZONE25DN_Sup = Index - (Index_ZONE25UP_Res-Index)
//check if the bar we're on is the start of the session according to the time and timezone variables
if IsSessionStart(sess_Time, sess_TimeZone)
close_time = time_close+86400000 // time offset for creating boxes in milliseconds
//Draw a box using all the calculated values
//the first box to be drawn is the 1 std. dev. box above the settlement price
Index_BOX_1TOP = box.new(
left = time_close, //the left side of the box in time
top = Index_ZONE1UP_Res, //the top of the box in price
right = close_time, //the right side of the box in time
bottom = Index_ZONE1DN_Res, //the bottom of the box in price
xloc = xloc.bar_time, //we wish to solve the box's x-coordinates in bar time
bgcolor = color.new(color.red, box_transparency),
//the box should be red and as transparent as the user indicates it to be
border_color = color.new(color.black,0)) //the border of the box to be black
//this box is the 1 std. dev. box below the settlement price
Index_BOX_1BTM = box.new(
left = time_close,
top = Index_ZONE1DN_Sup,
right = close_time,
bottom = Index_ZONE1UP_Sup,
xloc = xloc.bar_time,
bgcolor = color.new(color.green, box_transparency),
border_color = color.new(color.black,0))
//this is the 1.5 std. dev. box above the settlement price
Index_BOX_2TOP = box.new(
left = time_close,
top = Index_ZONE150UP_Res,
right = close_time,
bottom = Index_ZONE150DN_Res,
xloc = xloc.bar_time,
bgcolor = color.new(color.red, box_transparency),
border_color = color.new(color.black,0))
//this is the 1.5 std. dev. box below the settlement price
Index_BOX_2BTM = box.new(
left = time_close,
top = Index_ZONE150DN_Sup,
right = close_time,
bottom = Index_ZONE150UP_Sup,
xloc = xloc.bar_time,
bgcolor = color.new(color.green, box_transparency),
border_color = color.new(color.black,0))
//this is the 0.5 std. dev. box above the settlement price
Index_BOX_3TOP = box.new(
left = time_close,
top = Index_ZONE50UP_Res,
right = close_time,
bottom = Index_ZONE50DN_Res,
xloc = xloc.bar_time,
bgcolor = color.new(color.red, box_transparency),
border_color = color.new(color.black,0))
//this is the 0.5 std. dev. box below the settlement price
Index_BOX_3BTM = box.new(
left = time_close,
top = Index_ZONE50DN_Sup,
right = close_time,
bottom = Index_ZONE50UP_Sup,
xloc = xloc.bar_time,
bgcolor = color.new(color.green, box_transparency),
border_color = color.new(color.black,0))
//this is the 0.25 std. dev. box above the settlement price
Index_BOX_4TOP = box.new(
left = time_close,
top = Index_ZONE25UP_Res,
right = close_time,
bottom = Index_ZONE25DN_Res,
xloc = xloc.bar_time,
bgcolor = color.new(color.red, box_transparency),
border_color = color.new(color.black,0))
//this is the 0.25 std. dev. box below the settlement price
Index_BOX_4BTM = box.new(
left = time_close,
top = Index_ZONE25DN_Sup,
right = close_time,
bottom = Index_ZONE25UP_Sup,
xloc = xloc.bar_time,
bgcolor = color.new(color.green, box_transparency),
border_color = color.new(color.black,0))
//return the values after the function is done:
[a,b,Index]
//Here, we check which chart we are using to determine what zones to calculate:
//If we are on ES1!, we use the VIX and then calculate zones using a, b, and ES
if ticker.standard(syminfo.tickerid) == "CME_MINI:ES1!"
[VIX_A, VIX_B] = GetVolatility(VIX)
Zones(VIX_A,VIX_B, ES)
//if troubleshooting is on, and we see the index is ES1!, label it as such
if troubleshooting == true
label.new(timenow,close,"ES",xloc = xloc.bar_time)
//If we are on NQ1!, we use the VOLQ and then calculate zones using a, b, and NQ
else if ticker.standard(syminfo.tickerid) == "CME_MINI:NQ1!"
[VOLQ_A, VOLQ_B] = GetVolatility(VOLQ)
Zones(VOLQ_A, VOLQ_B, NQ)
if troubleshooting == true
label.new(timenow,close,"NQ",xloc = xloc.bar_time)
//If we are on CL1!, we use the OVX and then calculate zones using a, b, and CL
else if ticker.standard(syminfo.tickerid) == "NYMEX:CL1!"
[OVX_A, OVX_B] = GetVolatility(OVX)
Zones(OVX_A, OVX_B, CL)
if troubleshooting == true
label.new(timenow,close,"CL",xloc = xloc.bar_time)
//If we are on RTY1!, we use the RVX and then calculate zones using a, b, and RTY
else if ticker.standard(syminfo.tickerid) == "CME_MINI:RTY1!"
[RVX_A, RVX_B] = GetVolatility(RVX)
Zones(RVX_A, RVX_B, RTY)
if troubleshooting == true
label.new(timenow,close,"RTY",xloc = xloc.bar_time)
//If we are on VIX, we use the VVIX and then calculate zones using a, b, and VIX
else if ticker.standard(syminfo.tickerid) == "CBOE:VIX"
[VVIX_A, VVIX_B] = GetVolatility(VVIX)
Zones(VVIX_A, VVIX_B, VIX)
if troubleshooting == true
label.new(timenow,close,"VIX",xloc = xloc.bar_time)
//If we are on GC1!, we use the GVZ and then calculate zones using a, b, and GC
else if ticker.standard(syminfo.tickerid) == "COMEX:GC1!"
[GVZ_A, GVZ_B] = GetVolatility(GVZ)
Zones(GVZ_A, GVZ_B, GC)
if troubleshooting == true
label.new(timenow,close,"GC",xloc = xloc.bar_time)
//If we are on SILVER1!, we use the VXSLV and then calculate zones using a, b, and SI
//Note: the volatility index for silver is discontinued.
else if ticker.standard(syminfo.tickerid) == "MCX:SILVER1!"
[VXSLV_A, VXSLV_B] = GetVolatility(VXSLV)
Zones(VXSLV_A, VXSLV_B, SI)
if troubleshooting == true
label.new(timenow,close,"SILVER",xloc = xloc.bar_time)
//If we are on YM1!, we use the VXD and then calculate zones using a, b, and YM
else if ticker.standard(syminfo.tickerid) == "CBOT_MINI:YM1!"
[VXD_A, VXD_B] = GetVolatility(VXD)
Zones(VXD_A, VXD_B, YM)
if troubleshooting == true
label.new(timenow,close,"YM",xloc = xloc.bar_time)
else
//If we don't recognize the chart and we're troubleshooting, make a label signifying this.
if troubleshooting == true
label.new(timenow,close,"NOT RECOGNIZED.",xloc = xloc.bar_time) |
Volume Divergence Indicator | https://www.tradingview.com/script/nxR6JqcL-Volume-Divergence-Indicator/ | cyatophilum | https://www.tradingview.com/u/cyatophilum/ | 765 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © cyatophilum
//@version=5
indicator("Volume Divergence Indicator",overlay= true)
// Inputs {
displayMode = input.string('Overlay', 'Choose overlay mode',options=['Overlay','Non Overlay'])
overlay = displayMode == 'Overlay'
groupDivergences = '📈 Divergences Signals 📉'
priceLookBack = input.int(20, 'Price and volume Lookback', group = groupDivergences)
bullSensitivity = input.int(3, 'Bull Sensitivity',minval=1, group = groupDivergences) + 1
bearSensitivity = input.int(4, 'Bear Sensitivity',minval=1, group = groupDivergences) + 1
groupSpikes = 'Volume Spike 💥 & Contraction Signals ⤵'
maLength = input.int(20, 'Volume MA length', group = groupSpikes)
mult = input.float(3,'Sensitivity of Spikes', step=0.1, minval = 0.1, group = groupSpikes)
mult2 = input.float(1,'Sensitivity of Contractions', step=0.1, minval = 0.1, group = groupSpikes)
groupTrend = 'Volume Trend'
trendSensitivity = input.int(5,'Trend sensitivity',minval = 1, group = groupTrend)
// }
// Algorithm {
// Bullish Divergence: generate an alert when prices are making lower lows but volume is making higher lows. This would suggest that the selling pressure is weakening, and a bullish reversal may be imminent.
priceLowerLows = ta.lowest(low, priceLookBack) == ta.lowest(low, priceLookBack * bullSensitivity)
lowVol1 = ta.lowest(volume, priceLookBack)
lowVol2 = ta.lowest(volume, priceLookBack * bullSensitivity)
volumeHigherLows = lowVol1 > lowVol2
bullishDivergence = priceLowerLows and volumeHigherLows and not (priceLowerLows and volumeHigherLows)[1]
// Bearish Divergence: generate an alert when prices are making higher highs but volume is making lower highs. This would suggest that the buying pressure is weakening, and a bearish reversal may be imminent.
priceHigherHighs = ta.highest(high, priceLookBack) == ta.highest(high, priceLookBack * bearSensitivity)
highVol1 = ta.highest(volume, priceLookBack)
highVol2 = ta.highest(volume, priceLookBack * bearSensitivity)
volumeLowerHighs = highVol1 < highVol2
bearishDivergence = priceHigherHighs and volumeLowerHighs and not (priceHigherHighs and volumeLowerHighs)[1]
// Volume Spike: generate an alert when volume spikes above a certain threshold, such as two standard deviations above the moving average.
// This would suggest that there is unusual buying or selling activity in the market, and traders may want to pay attention to the price movements that follow.
volMA = ta.sma(volume, maLength)
volDev = mult * ta.stdev(volume,maLength)
volDev2 = mult2 * ta.stdev(volume,maLength)
upperDevVol1 = volMA + volDev
volumeSpike = ta.crossover(volume,upperDevVol1)
// Volume Contraction: generate an alert when volume contracts to a certain level, such as two standard deviations below the moving average.
// This would suggest that there is little buying or selling activity in the market, and traders may want to be cautious until volume picks up again.
lowerDevVol1 = volMA - volDev2
volumeContraction = ta.crossunder(volume,lowerDevVol1) and barstate.isconfirmed
// Volume Trend: an alert when volume trends above or below the moving average for a certain number of periods, such as five or ten.
// This would suggest that there is a sustained increase or decrease in buying or selling pressure, and traders may want to adjust their trading strategy accordingly.
increasingTrend = ta.barssince(volume < volMA) > trendSensitivity
decreasingTrend = ta.barssince(volume > volMA) > trendSensitivity
// }
// Rendering {
plotshape(bullishDivergence,'Bullish Divergence',shape.labelup,location.belowbar,color.lime,text='Bull', textcolor=#000000,size=size.normal, display=not(overlay) ? display.none : display.all)
plotshape(bearishDivergence,'Bearish Divergence',shape.labeldown,location.abovebar,color.red,text='Bear', textcolor=#FFFFFF,size=size.normal, display=not(overlay) ? display.none : display.all)
plotchar(volumeSpike, 'Volume Spike', '💥', size=size.small, display=not(overlay) ? display.none : display.all)
plotchar(volumeContraction, 'Volume Contraction', '⤵', size=size.small, display=not(overlay) ? display.none : display.all, color=color.aqua)
plotshape(increasingTrend and not increasingTrend[1],'Increasing Trend',shape.labelup,location.belowbar, color.rgb(0,0,0,100),text='Strong Trend',textcolor= color.rgb(77, 160, 255),size=size.small, display=not(overlay) ? display.none : display.all)
plotshape(decreasingTrend and not decreasingTrend[1],'Decreasing Trend',shape.labeldown,location.abovebar,color.rgb(0,0,0,100),text='Weak Trend',textcolor=color.orange,size=size.small, display=not(overlay) ? display.none : display.all)
plot(volume,'Volume',color= bullishDivergence ? color.lime : bearishDivergence ? color.red : volumeSpike ? color.yellow : volumeContraction ? color.aqua : color.rgb(119, 119, 119, 50),style=plot.style_columns, display=overlay ? display.none : display.all, linewidth = 2)
pvolMA = plot(volMA, 'Volume MA',color=increasingTrend ? color.lime : decreasingTrend ? color.red : chart.fg_color, linewidth = 2, display=overlay ? display.none : display.all)
pdevVol1 = plot(upperDevVol1, 'stdevVol1',color.rgb(0, 230, 119, 50), display=overlay ? display.none : display.all,linewidth = 2)
pdevVol2 = plot(lowerDevVol1, 'stdevVol2',color.rgb(255, 82, 82, 50), display=overlay ? display.none : display.all,linewidth = 2)
fill(pvolMA,pdevVol1,color.rgb(0, 230, 119, 85), display=overlay ? display.none : display.all)
fill(pvolMA,pdevVol2,color.rgb(230, 0, 0, 85), display=overlay ? display.none : display.all)
// }
// Alerts {
alertcondition(bullishDivergence,'Bullish Divergence')
alertcondition(bearishDivergence,'Bearish Divergence')
alertcondition(volumeSpike, 'Volume Spike')
alertcondition(volumeContraction,'Volume Contraction')
alertcondition(increasingTrend and not increasingTrend[1],'Increasing Trend')
alertcondition(decreasingTrend and not decreasingTrend[1],'Decreasing Trend')
//} |
Volume Weighted Pivot Point Moving Averages VPPMA | https://www.tradingview.com/script/xEta7cB9-Volume-Weighted-Pivot-Point-Moving-Averages-VPPMA/ | peacefulLizard50262 | https://www.tradingview.com/u/peacefulLizard50262/ | 37 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
indicator("PPMA", overlay = true)
timeframe = input.timeframe(defval = '240')
leftBars = input.int(defval = 2, title = "Left Bars", minval = 1)
rightBars = input.int(defval = 2, title = "Right Bars", minval = 1)
get_phpl()=>
float ph = ta.pivothigh(leftBars, rightBars)
float pl = ta.pivotlow(leftBars, rightBars)
phtimestart = ph ? time[rightBars] : na
phtimeend = ph ? time[rightBars - 1] : na
pltimestart = pl ? time[rightBars] : na
pltimeend = pl ? time[rightBars - 1] : na
[ph, phtimestart, phtimeend, pl, pltimestart, pltimeend]
// get if there if Pivot High/low and their start/end times
[ph, phtimestart, phtimeend, pl, pltimestart, pltimeend] = request.security(syminfo.tickerid, timeframe, get_phpl(), lookahead = barmerge.lookahead_on)
// keep time of each bars, this is used for lines/labels
var mytime = array.new_int(0)
array.unshift(mytime, time)
// calculate end of the line/time for pivot high/low
bhend = array.get(mytime, math.min(array.indexof(mytime, phtimeend) + 1, array.size(mytime) - 1))
blend = array.get(mytime, math.min(array.indexof(mytime, pltimeend) + 1, array.size(mytime) - 1))
// to draw once
float pivothigh = na(ph[1]) and ph ? ph : na
float pivotlow = na(pl[1]) and pl ? pl : na
vppma()=>
signal = ta.change(pivothigh or pivotlow)
var int count = na
var float sum = na
var float volume_sum = na
if not signal
count := nz(count[1]) + 1
sum := nz(sum[1]) + close * volume
volume_sum := nz(volume_sum[1]) + volume
else
count := na
sum := na
volume_sum := na
sum/volume_sum
plot(vppma())
|
Stophunt Wick | https://www.tradingview.com/script/KPTUDGYk-Stophunt-Wick/ | KiLA-WHALE | https://www.tradingview.com/u/KiLA-WHALE/ | 143 | study | 5 | MPL-2.0 | // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © KiLA-WHALE
// What's a Stophunt Wick? It's that fast stophunting wick that cucks everyone by triggering their stoploss.
// This indicator is dedicated to my friend Alexandru who saved me from getting liquidated by one of these scam wicks which almost liquidated me.
// Alexandru is one of the best scalpers out there and he always nails his entries at the tip of these wicks. This inspired me to create this indicator.
//@version=5
// Declare indicator name
indicator('Stophunt Wick', overlay=true)
// Define variables
Wick_Ratio = input(2.0,'Wick Ratio',tooltip = 'Candle wick to body size ratio.')
Candle_Ratio = input(0.5, 'Candle Ratio', tooltip = 'Percentage of current price.')
AlertCandleSize = input(5,'Alert Candle Size',tooltip = 'Size stophunt candle used for alert')
Bull_Candle_Colour = input(color.green, 'Bull Candle Colour',tooltip = 'Colour of the bullish stophunt candle.')
Bear_Candle_Colour = input(color.red, 'Bear Candle Colour',tooltip = 'Colour of the bearish stophunt candle.')
AlertCandlePrice = (Candle_Ratio * close) / 100
// Display the result on the chart
plot(AlertCandlePrice, title="Stophunt Candle Size")
// Calculate the size of the body of a candle
body = math.abs(close - open)
// Calculate the size of the upper wick of a candle
upper_wick = high - math.max(open, close)
// Calculate the size of the lower wick of a candle
lower_wick = math.min(open, close) - low
// Find bull Stophunt by calculating size of the wick and body
BullStophunt = body + upper_wick + lower_wick >= (Candle_Ratio * close) / 100 and (upper_wick > (body + lower_wick) * Wick_Ratio)
// Find bear Stophunt by calculating size of the wick and body
BearStophunt = body + upper_wick + lower_wick >= (Candle_Ratio * close) / 100 and (lower_wick > (body + upper_wick) * Wick_Ratio)
// Highlight Stophunt Wick with the specified colours
Stophunt_Wick = (BullStophunt ? Bull_Candle_Colour : BearStophunt ? Bear_Candle_Colour : na)
// Highlight Stophunt candles and Stophunt Wicks
barcolor(BullStophunt ? Bull_Candle_Colour : BearStophunt ? Bear_Candle_Colour : na)
// Find the current candle
Current_Candle = barstate.islast ? 1 : 0
// Get the closing price of the current 5 minute candle
ClosePrice = request.security(syminfo.tickerid, str.tostring(AlertCandleSize), close)
// Find current bull Stophunt
CurrentBullStophunt = ClosePrice - open > (Candle_Ratio * close) / 100
// Find current bear Stophunt
CurrentBearStophunt = math.abs(ClosePrice - open) > (Candle_Ratio * close) / 100
// Highlight Stophunt Wick with the specified colours
Stophunt_Current = (CurrentBullStophunt ? Bull_Candle_Colour : CurrentBearStophunt ? Bear_Candle_Colour : na)
// Apply the color to 5 minute candles only
barcolor(Current_Candle and timeframe.multiplier == AlertCandleSize and timeframe.isintraday ? Stophunt_Current : na)
// Calculate current candle size
CurrentCandleSize = math.abs(ClosePrice - open)
// Alert if stophunt is currently underway
if CurrentCandleSize > (Candle_Ratio * close) / 100 and Current_Candle and timeframe.multiplier == AlertCandleSize and timeframe.isintraday
alert("Price has moved " + str.tostring(CurrentCandleSize) + " in last "+ str.tostring(AlertCandleSize) + "minutes") |
Subsets and Splits