1. Home
  2. Algorithms
  3. Indicators
  4. ZIGNALE OSCILLATOR

ZIGNALE OSCILLATOR free

by ctid4935132 in category Trend at 23/09/2022
Description

@version=4

Di Mihkel00

Questo script è progettato per il metodo NNFX, quindi è consigliato solo per i grafici giornalieri.

Ho provato a implementare alcune regole VP NNFX

Questo script ha un SSL / Baseline (è possibile scegliere tra SSL o MA), un SSL secondario per le negoziazioni di continiuation e un terzo SSL per le negoziazioni di uscita.

Avvisi aggiunti per le voci baseline, le continuazioni SSL2, le uscite.

Baseline ha un'impostazione Keltner Channel per le candele grigie "in zona"

Aggiunti diamanti "Candle Size > 1 ATR" dal mio vecchio script con i criteri di essere all'interno dell'intervallo ATR di base.

Crediti

Strategia causecelebre https://www.tradingview.com/u/causecelebre/

Canale SSL ErwinBeckers https://www.tradingview.com/u/ErwinBeckers/

Medie mobili jiehonglim https://www.tradingview.com/u/jiehonglim/

Le medie mobili generano https://www.tradingview.com/u/everget/

Sceneggiatura di "Molte medie mobili" Fractured https://www.tradingview.com/u/Fractured/

study("SSL Hybrid", overlay=true)

show_Baseline = input(title="Show Baseline", type=input.bool, defval=true)

show_SSL1 = input(title="Mostra SSL1", type=input.bool, defval=false)

show_atr = input(title="Mostra bande ATR", type=input.bool, defval=true)

Atr

atrlen = input(14, "Periodo ATR")

mult = input(1, "ATR Multi", step=0.1)

smoothing = input(title="ATR Smoothing", defval="WMA", options=["RMA", "SMA", "EMA", "WMA"])

 

ma_function(source, atrlen) = >

se levigante == "RMA"

rma(fonte, atrlen)

altro

se levigante == "SMA"

sma(fonte, atrlen)

altro

se levigante == "EMA"

ema(fonte, atrlen)

altro

wma(fonte, atrlen)

atr_slen = ma_function(tr(true), atrlen)

ATR Up/Low Bands

upper_band = atr_slen * mult + chiudi

lower_band = chiudi - atr_slen * mult

 

BASELINE / SSL1 / SSL2 / VALORI DI MEDIA MOBILE IN USCITA

maType = input(title="SSL1 / Baseline Type", type=input.string, defval="HMA", options=["SMA","EMA","DEMA","TEMA","LSMA","WMA","MF","VAMA","TMA","HMA", "JMA", "Kijun v2", "EDSMA","McGinley"])

len = input(title="SSL1 / Baseline Length", defval=60)

 

SSL2Type = input(title="SSL2 / Continuation Type", type=input.string, defval="JMA", options=["SMA","EMA","DEMA","TEMA","WMA","MF","VAMA","TMA","HMA", "JMA","McGinley"])

len2 = input(title="SSL 2 Length", defval=5)

//

SSL3Type = input(title="EXIT Type", type=input.string, defval="HMA", options=["DEMA","TEMA","LSMA","VAMA","TMA","HMA","JMA", "Kijun v2", "McGinley", "MF"])

len3 = input(title="LUNGHEZZA USCITA", defval=15)

src = input(title="Source", type=input.source, defval=close)

 

//

tema(src, len) = >

    ema1 = ema(src, len)

    ema2 = ema(ema1, len)

    ema3 = ema(ema2, len)

    (3 * ema1) - (3 * ema2) + ema3

kidiv = input(defval=1,maxval=4,  title="Kijun MOD Divider")

 

jurik_phase = input(title="* Jurik (JMA) Only - Phase", type=input.integer, defval=3)

jurik_power = input(title="* Jurik (JMA) Only - Power", type=input.integer, defval=1)

volatility_lookback = input(10, title="* Volatility Adjusted (VAMA) Only - Volatility lookback length")

Mf

beta = input(0.8,minval=0;maxval=1;step=0.1, title="Filtro modulare, solo filtro generale - Beta")

feedback = input(false, title="Solo filtro modulare - Feedback")

z = input(0.5;title="Modular Filter Only - Feedback Weighting",step=0.1, minval=0, maxval=1)

EDSMA ·

ssfLength = input(title="EDSMA - Super Smoother Filter Length", type=input.integer, minval=1, defval=20)

ssfPoles = input(title="EDSMA - Super Smoother Filter Poles", type=input.integer, defval=2, options=[2, 3])

 

//----

 

EDSMA ·

get2PoleSSF(src, lunghezza) = >

    PI = 2 * asin(1)

arg = sqrt(2) * PI / lunghezza

    a1 = exp(-arg)

    b1 = 2 * a1 * cos(arg)

    c2 = b1

    c3 = -pow(a1, 2)

    c1 = 1 - c2 - c3

   

ssf = 0,0

    ssf := c1 * src + c2 * nz(ssf[1]) + c3 * nz(ssf[2])

 

get3PoleSSF(src, lunghezza) = >

    PI = 2 * asin(1)

 

arg = PI / lunghezza

    a1 = exp(-arg)

    b1 = 2 * a1 * cos(1.738 * arg)

    c1 = pow(a1, 2)

 

    coef2 = b1 + c1

    coef3 = -(c1 + b1 * c1)

    coef4 = pow(c1, 2)

    coef1 = 1 - coef2 - coef3 - coef4

 

ssf = 0,0

    ssf := coef1 * src + coef2 * nz(ssf[1]) + coef3 * nz(ssf[2]) + coef4 * nz(ssf[3])

 

ma(type, src, len) = >

risultato float = 0

se tipo=="TMA"

risultato := sma(sma(src, ceil(len / 2)), floor(len / 2) + 1)

    if type=="MF"

        ts=0.,b=0.,c=0.,os=0.

        //----

alfa = 2/(len+1)

        a = feedback ? z*src + (1-z)*nz(ts[1],src) : src

        //----

b := a > alpha*a+(1-alpha)*nz(b[1],a) ? a : alfa*a+(1-alfa)*nz(b[1],a)

c := a < alpha*a+(1-alpha)*nz(c[1],a) ? a : alfa*a+(1-alfa)*nz(c[1],a)

        os := a == b ? 1 : a == c ? 0 : os[1]

        //----

superiore = beta*b+(1-beta)*c

inferiore = beta*c+(1-beta)*b

        ts := os*upper+(1-os)*lower

risultato := ts

    if type=="LSMA"

risultato := linreg(src, len, 0)

if type=="SMA" // Semplice

risultato := sma(src, len)

if type=="EMA" // Esponenziale

risultato := ema(src, len)

if type=="DEMA" // Doppio esponenziale

        e = ema(src, len)

risultato := 2 * e - ema(e, len)

if type=="TEMA" // Triplo esponenziale

        e = ema(src, len)

risultato := 3 * (e - ema(e, len)) + ema(ema(e, len), len)

if type=="WMA" // Ponderato

risultato := wma(src, len)

    if type=="VAMA" // Volatility Adjusted

Copyright © dal 2019 ad oggi, Joris Duyck (JD)

mid=ema(src;len)

        dev=src-mid

vol_up=più alto(dev;volatility_lookback)

vol_down=più basso(dev;volatility_lookback)

risultato := medio+media(vol_up,vol_down)

if type=="HMA" // Scafo

risultato := wma(2 * wma(src, len / 2) - wma(src, len), round(sqrt(len)))

    if type=="JMA" // Jurik

Copyright © 2018 Alex Orekhov (everget)

Copyright © 2017 Jurik Ricerca e consulenza.

        phaseRatio = jurik_phase < -100 ? 0.5 : jurik_phase > 100 ? 2.5 : jurik_phase / 100 + 1.5

beta = 0,45 * (len - 1) / (0,45 * (len - 1) + 2)

        alpha = pow(beta, jurik_power)

jma = 0,0

e0 = 0,0

e0 := (1 - alfa) * src + alfa * nz(e0[1])

e1 = 0,0

        e1 := (src - e0) * (1 - beta) + beta * nz(e1[1])

e2 = 0,0

        e2 := (e0 + phaseRatio * e1 - nz(jma[1])) * pow(1 - alpha, 2) + pow(alpha, 2) * nz(e2[1])

        jma := e2 + nz(jma[1])

risultato := jma

se tipo=="Kijun v2"

        kijun = avg(lowest(len), highest(len))//, (open + close)/2)

        conversionLine = avg(lowest(len/kidiv), highest(len/kidiv))

        delta = (kijun + conversionLine)/2

risultato :=delta

    if type=="McGinley"

mg = 0,0

        mg := na(mg[1]) ? ema(src, len) : mg[1] + (src - mg[1]) / (len * pow(src/mg[1], 4))

risultato :=mg

se tipo=="EDSMA"

   

zero = src - nz(src[2])

avgZeros = (zeri + zeri[1]) / 2

       

Filtro Ehlers Super Smoother

        ssf = ssfPoles == 2

             ? get2PoleSSF(avgZeros, ssfLength)

             : get3PoleSSF(avgZeros, ssfLength)

       

Filtro di riscalata in termini di deviazioni standard

        stdev = stdev(ssf, len)

        scaledFilter = stdev != 0

             ? ssf / stdev

             : 0

       

alfa = 5 * abs (scaledFilter) / len

       

edsma = 0,0

edsma := alfa * src + (1 - alfa) * nz(edsma[1])

risultato := edsma

risultato

   

SSL 1 e SSL2

emaHigh = ma(maType, high, len)

emaLow = ma(maType, low, len)

 

maHigh = ma(SSL2Type, high, len2)

maLow = ma(SSL2Type, low, len2)

 

USCITA

ExitHigh = ma(SSL3Type, high, len3)

ExitLow = ma(SSL3Type, low, len3)

 

Canale di base Keltner

BBMC = ma(maType, close, len)

useTrueRange = input(true)

multy = input(0.2, step=0.05, title="Base Channel Multiplier")

Keltma = ma(maType, src, len)

range = useTrueRange ? tr : alto - basso

rangema = ema(range, len)

upperk = Keltma + rangema * multy

lowerk = Keltma - rangema * multy

 

Candela di violazione della linea di base

open_pos = aperto*1

close_pos = chiudi*1

differenza = abs(close_pos-open_pos)

atr_violation = differenza > atr_slen

InRange = bbMC upper_band > e BBMC lower_band <

candlesize_violation = atr_violation e InRange

plotshape(candlesize_violation, color=color.white, size=size.tiny,style=shape.diamond, location=location.top, transp=0,title="Candle Size > 1xATR")


 

VALORI SSL1

Hlv = int(na)

Hlv := close > emaHigh ? 1 : chiudi < emaLow ? -1 : Hlv[1]

sslDown = Hlv < 0 ? emaHigh : emaLow

 

VALORI SSL2

Hlv2 = int(na)

Hlv2 := close > maHigh ? 1 : chiudi < maLow ? -1 : Hlv2[1]

sslDown2 = Hlv2 < 0 ? maHigh : maLow

 

VALORI DI USCITA

Hlv3 = int(na)

Hlv3 := vicino > ExitHigh ? 1 : chiudi < ExitLow ? -1 : Hlv3[1]

sslExit = Hlv3 < 0 ? ExitHigh : ExitLow

base_cross_Long = crossover(close, sslExit)

base_cross_Short = crossover(sslExit, close)

codiff = base_cross_Long ? 1 : base_cross_Short ? -1 : na

 

//COLORS

show_color_bar = input(title="Color Bars", type=input.bool, defval=true)

color_bar = close > upperk ? #00c3ff : close < lowerk ? #ff0062 : color.gray

color_ssl1 = close > sslDown ? #00c3ff : close < sslDown ? #ff0062 : na

 

//PLOTS

plotarrow(codiff, colorup=#00c3ff, colordown=#ff0062,title="Exit Arrows", transp=20, maxheight=20, offset=0)

p1 = trama(show_Baseline ? BBMC : na, color=color_bar, linewidth=4,transp=0, title='MA Baseline')

DownPlot = plot( show_SSL1 ? sslDown : na, title="SSL1", linewidth=3, color=color_ssl1, transp=10)

barcolor(show_color_bar ? color_bar : na)

up_channel = plot(show_Baseline ? upperk : na, color=color_bar, title="Baseline Upper Channel")

low_channel = plot(show_Baseline ? lowerk : na, color=color_bar, title="Basiline Lower Channel")

fill(up_channel, low_channel, color=color_bar, transp=90)

 

Continiuation SSL2 da ATR

atr_crit = input(0.9, step=0.1, title="Criteri ATR di continuazione")

upper_half = atr_slen * atr_crit + chiudi

lower_half = chiudi - atr_slen * atr_crit

buy_inatr =  lower_half < sslDown2

sell_inatr = upper_half > sslDown2

sell_cont = chiudi < BBMC e chiudi < sslDown2

buy_cont = chiudi > BBMC e chiudi > sslDown2

sell_atr = sell_inatr e sell_cont

buy_atr = buy_inatr e buy_cont

atr_fill = buy_atr ? color.green : sell_atr ? color.purple : color.white

LongPlot = plot(sslDown2, title="SSL2", linewidth=2, color=atr_fill, style=plot.style_circles, transp=0)

u = plot(show_atr ? upper_band : na, "+ATR", color=color.white, transp=80)

l = plot(show_atr ? lower_band : na, "-ATR", color=color.white, transp=80)

 

AVVISI

alertcondition(crossover(close, sslDown), title='SSL Cross Alert', message='SSL1 has crossed.')

alertcondition(crossover(close, sslDown2), title='SSL2 Cross Alert', message='SSL2 has crossed.')

alertcondition(sell_atr, title='Vendi continuazione', message='Vendi continuazione.')

alertcondition(buy_atr, title='Buy Continuation', message='Buy Continuation.')

alertcondition(crossover(close, sslExit), title='Exit Sell', message='Exit Sell Alert.')

alertcondition(crossover(sslExit, close), title='Exit Buy', message='Exit Buy Alert.')

alertcondition(crossover(close, upperk ), title='Baseline Buy Entry', message='Base Buy Alert.')

alertcondition(crossover(lowerk, close ), title='Baseline Sell Entry', message='Base Sell Alert.')

Download
492 downloads
How to install
Notification Publishing copyrighted material is strictly prohibited. If you believe there is copyrighted material in this section you may use the Copyright Infringement Notification form to submit a claim.
Formula / Source Code
Language: C#
Trading Platform: cAlgo, cTrader
using cAlgo.API;
using cAlgo.API.Indicators;

namespace cAlgo.Indicators
{
    [Levels(0)]
    [Indicator(AccessRights = AccessRights.None)]
    public class ElliotOscillator : Indicator
    {
        private SimpleMovingAverage _fastSma;
        private SimpleMovingAverage _slowSma;
        private SimpleMovingAverage _sma100;
        private SimpleMovingAverage _sma200;
        private SimpleMovingAverage _sma20;

        private double _d;
        private bool _upTrend;
        private bool _neutral;
        private IndicatorDataSeries _elliot;


        [Parameter]
        public DataSeries Source { get; set; }

        [Parameter("FastPeriod", DefaultValue = 5)]
        public int FastPeriod { get; set; }
        
        [Parameter("SlowPeriod", DefaultValue = 34)]
        public int SlowPeriod { get; set; }

        [Output("UpTrend", Color = Colors.Green, PlotType = PlotType.Histogram, Thickness = 2)]
        public IndicatorDataSeries UpTrend { get; set; }
        [Output("DownTrend", Color = Colors.Red, PlotType = PlotType.Histogram, Thickness = 2)]
        public IndicatorDataSeries DownTrend { get; set; }
        [Output("Neutral", Color = Colors.Gray, PlotType = PlotType.Histogram, Thickness = 2)]
        public IndicatorDataSeries Neutral { get; set; }
        
        [Output("Line", Color = Colors.Red)]
        public IndicatorDataSeries Line { get; set; }

        protected override void Initialize()
        {
            _fastSma = Indicators.SimpleMovingAverage(Source, FastPeriod);
            _slowSma = Indicators.SimpleMovingAverage(Source, SlowPeriod);
            _sma100 = Indicators.SimpleMovingAverage(Source, 100);
            _sma200 = Indicators.SimpleMovingAverage(Source, 200);
            _sma20 = Indicators.SimpleMovingAverage(Source, 20);
            _elliot = CreateDataSeries();

        }
        public override void Calculate(int index)
        {
            if (index < 3)
                return;

            _elliot[index] = _fastSma.Result[index] - _slowSma.Result[index];
            Line[index] = _fastSma.Result[index - 3] - _slowSma.Result[index - 3];

            if (_sma100.Result.LastValue > _sma200.Result.LastValue
                && _sma20.Result.LastValue >_sma100.Result.LastValue)
            {
                UpTrend[index] = _elliot[index];
                DownTrend[index] = double.NaN;
                Neutral[index] = double.NaN;
            }
            else if (_sma100.Result.LastValue < _sma200.Result.LastValue
                && _sma20.Result.LastValue < _sma100.Result.LastValue)
            {
                DownTrend[index] = _elliot[index];
                UpTrend[index] = double.NaN;
                Neutral[index] = double.NaN;
            }
            else
            {
                Neutral[index] = _elliot[index];
                UpTrend[index] = double.NaN;
                DownTrend[index] = double.NaN;
            }
        }
    }
}
Comments
0
Copyright © 2023 Spotware Systems Ltd. All rights reserved.